home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / bash-1.12 / dist / y.tab.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-01-25  |  105.6 KB  |  3,796 lines
  1.  
  2. /*  A Bison parser, made from parse.y  */
  3.  
  4. #define    IF    258
  5. #define    THEN    259
  6. #define    ELSE    260
  7. #define    ELIF    261
  8. #define    FI    262
  9. #define    CASE    263
  10. #define    ESAC    264
  11. #define    FOR    265
  12. #define    WHILE    266
  13. #define    UNTIL    267
  14. #define    DO    268
  15. #define    DONE    269
  16. #define    FUNCTION    270
  17. #define    IN    271
  18. #define    BANG    272
  19. #define    WORD    273
  20. #define    NUMBER    274
  21. #define    AND_AND    275
  22. #define    OR_OR    276
  23. #define    GREATER_GREATER    277
  24. #define    LESS_LESS    278
  25. #define    LESS_AND    279
  26. #define    GREATER_AND    280
  27. #define    SEMI_SEMI    281
  28. #define    LESS_LESS_MINUS    282
  29. #define    AND_GREATER    283
  30. #define    LESS_GREATER    284
  31. #define    GREATER_BAR    285
  32. #define    yacc_EOF    286
  33.  
  34. #line 21 "parse.y"
  35.  
  36. #include <stdio.h>
  37. #include <sys/types.h>
  38. #include <signal.h>
  39. #include "shell.h"
  40. #include "flags.h"
  41. #include "input.h"
  42.  
  43. #if defined (READLINE)
  44. #include <readline/readline.h>
  45. #endif /* READLINE */
  46.  
  47. #include <readline/history.h>
  48.  
  49. #if defined (JOB_CONTROL)
  50. #  include "jobs.h"
  51. #endif /* JOB_CONTROL */
  52.  
  53. #define YYDEBUG 1
  54. extern int eof_encountered;
  55. extern int no_line_editing;
  56. extern int interactive, interactive_shell;
  57.  
  58. /* **************************************************************** */
  59. /*                                    */
  60. /*            "Forward" declarations                */
  61. /*                                    */
  62. /* **************************************************************** */
  63.  
  64. /* This is kind of sickening.  In order to let these variables be seen by
  65.    all the functions that need them, I am forced to place their declarations
  66.    far away from the place where they should logically be found. */
  67.  
  68. static int reserved_word_acceptable ();
  69.  
  70. /* PROMPT_STRING_POINTER points to one of these, never to an actual string. */
  71. char *ps1_prompt, *ps2_prompt;
  72.  
  73. /* Handle on the current prompt string.  Indirectly points through
  74.    ps1_ or ps2_prompt. */
  75. char **prompt_string_pointer = (char **)NULL;
  76. char *current_prompt_string;
  77.  
  78. /* The number of lines read from input while creating the current command. */
  79. int current_command_line_count = 0;
  80.  
  81. /* Variables to manage the task of reading here documents, because we need to
  82.    defer the reading until after a complete command has been collected. */
  83. REDIRECT *redirection_needing_here_doc = (REDIRECT *)NULL;
  84. int need_here_doc = 0;
  85.  
  86. #line 73 "parse.y"
  87. typedef union {
  88.   WORD_DESC *word;        /* the word that we read. */
  89.   int number;            /* the number that we read. */
  90.   WORD_LIST *word_list;
  91.   COMMAND *command;
  92.   REDIRECT *redirect;
  93.   ELEMENT element;
  94.   PATTERN_LIST *pattern;
  95. } YYSTYPE;
  96.  
  97. #ifndef YYLTYPE
  98. typedef
  99.   struct yyltype
  100.     {
  101.       int timestamp;
  102.       int first_line;
  103.       int first_column;
  104.       int last_line;
  105.       int last_column;
  106.       char *text;
  107.    }
  108.   yyltype;
  109.  
  110. #define YYLTYPE yyltype
  111. #endif
  112.  
  113. #include <stdio.h>
  114.  
  115. #ifndef __STDC__
  116. #define const
  117. #endif
  118.  
  119.  
  120.  
  121. #define    YYFINAL        228
  122. #define    YYFLAG        -32768
  123. #define    YYNTBASE    43
  124.  
  125. #define YYTRANSLATE(x) ((unsigned)(x) <= 286 ? yytranslate[x] : 68)
  126.  
  127. static const char yytranslate[] = {     0,
  128.      2,     2,     2,     2,     2,     2,     2,     2,     2,    33,
  129.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  130.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  131.      2,     2,     2,     2,     2,     2,     2,    31,     2,    41,
  132.     42,     2,     2,     2,    38,     2,     2,     2,     2,     2,
  133.      2,     2,     2,     2,     2,     2,     2,     2,    32,    37,
  134.      2,    36,     2,     2,     2,     2,     2,     2,     2,     2,
  135.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  136.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  137.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  138.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  139.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  140.      2,     2,    39,    35,    40,     2,     2,     2,     2,     2,
  141.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  142.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  143.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  144.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  145.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  146.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  147.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  148.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  149.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  150.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  151.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  152.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  153.      2,     2,     2,     2,     2,     1,     2,     3,     4,     5,
  154.      6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
  155.     16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
  156.     26,    27,    28,    29,    30,    34
  157. };
  158.  
  159. static const short yyprhs[] = {     0,
  160.      0,     3,     5,     8,    10,    11,    14,    17,    20,    24,
  161.     28,    31,    35,    38,    42,    45,    49,    52,    56,    59,
  162.     63,    66,    70,    73,    77,    80,    84,    87,    91,    94,
  163.     98,   101,   104,   108,   110,   112,   114,   117,   119,   122,
  164.    124,   126,   128,   131,   134,   141,   148,   156,   164,   175,
  165.    186,   193,   201,   208,   210,   216,   222,   226,   228,   234,
  166.    241,   246,   252,   260,   267,   271,   276,   283,   289,   291,
  167.    294,   299,   304,   310,   316,   318,   321,   327,   333,   340,
  168.    347,   349,   353,   356,   358,   362,   366,   370,   375,   380,
  169.    385,   390,   395,   397,   400,   402,   404,   406,   407,   410,
  170.    412,   415,   418,   423,   428,   432,   436,   438,   441,   446
  171. };
  172.  
  173. static const short yyrhs[] = {    65,
  174.     33,     0,    33,     0,     1,    33,     0,    34,     0,     0,
  175.     44,    18,     0,    36,    18,     0,    37,    18,     0,    19,
  176.     36,    18,     0,    19,    37,    18,     0,    22,    18,     0,
  177.     19,    22,    18,     0,    23,    18,     0,    19,    23,    18,
  178.      0,    24,    19,     0,    19,    24,    19,     0,    25,    19,
  179.      0,    19,    25,    19,     0,    24,    18,     0,    19,    24,
  180.     18,     0,    25,    18,     0,    19,    25,    18,     0,    27,
  181.     18,     0,    19,    27,    18,     0,    25,    38,     0,    19,
  182.     25,    38,     0,    24,    38,     0,    19,    24,    38,     0,
  183.     28,    18,     0,    19,    29,    18,     0,    29,    18,     0,
  184.     30,    18,     0,    19,    30,    18,     0,    18,     0,    45,
  185.      0,    45,     0,    47,    45,     0,    46,     0,    48,    46,
  186.      0,    48,     0,    50,     0,    51,     0,    51,    47,     0,
  187.     47,    51,     0,    10,    18,    64,    13,    60,    14,     0,
  188.     10,    18,    64,    39,    60,    40,     0,    10,    18,    32,
  189.     64,    13,    60,    14,     0,    10,    18,    32,    64,    39,
  190.     60,    40,     0,    10,    18,    64,    16,    44,    63,    64,
  191.     13,    60,    14,     0,    10,    18,    64,    16,    44,    63,
  192.     64,    39,    60,    40,     0,     8,    18,    64,    16,    64,
  193.      9,     0,     8,    18,    64,    16,    57,    64,     9,     0,
  194.      8,    18,    64,    16,    55,     9,     0,    52,     0,    11,
  195.     60,    13,    60,    14,     0,    12,    60,    13,    60,    14,
  196.      0,    41,    60,    42,     0,    53,     0,    18,    41,    42,
  197.     64,    53,     0,    15,    18,    41,    42,    64,    53,     0,
  198.     15,    18,    64,    53,     0,     3,    60,     4,    60,     7,
  199.      0,     3,    60,     4,    60,     5,    60,     7,     0,     3,
  200.     60,     4,    60,    54,     7,     0,    39,    60,    40,     0,
  201.      6,    60,     4,    60,     0,     6,    60,     4,    60,     5,
  202.     60,     0,     6,    60,     4,    60,    54,     0,    56,     0,
  203.     57,    56,     0,    64,    59,    42,    60,     0,    64,    59,
  204.     42,    64,     0,    64,    41,    59,    42,    60,     0,    64,
  205.     41,    59,    42,    64,     0,    58,     0,    57,    58,     0,
  206.     64,    59,    42,    60,    26,     0,    64,    59,    42,    64,
  207.     26,     0,    64,    41,    59,    42,    60,    26,     0,    64,
  208.     41,    59,    42,    64,    26,     0,    18,     0,    59,    35,
  209.     18,     0,    64,    61,     0,    62,     0,    62,    33,    64,
  210.      0,    62,    31,    64,     0,    62,    32,    64,     0,    62,
  211.     20,    64,    62,     0,    62,    21,    64,    62,     0,    62,
  212.     31,    64,    62,     0,    62,    32,    64,    62,     0,    62,
  213.     33,    64,    62,     0,    67,     0,    17,    67,     0,    33,
  214.      0,    32,     0,    34,     0,     0,    64,    33,     0,    66,
  215.      0,    66,    31,     0,    66,    32,     0,    66,    20,    64,
  216.     66,     0,    66,    21,    64,    66,     0,    66,    31,    66,
  217.      0,    66,    32,    66,     0,    67,     0,    17,    67,     0,
  218.     67,    35,    64,    67,     0,    49,     0
  219. };
  220.  
  221. #if YYDEBUG != 0
  222. static const short yyrline[] = { 0,
  223.    114,   123,   130,   146,   156,   158,   162,   164,   166,   168,
  224.    170,   172,   174,   180,   186,   190,   194,   198,   202,   207,
  225.    212,   217,   222,   229,   236,   238,   240,   242,   244,   246,
  226.    248,   258,   260,   264,   266,   270,   274,   285,   287,   291,
  227.    293,   297,   299,   302,   306,   308,   310,   312,   315,   317,
  228.    320,   322,   324,   329,   331,   333,   336,   339,   342,   345,
  229.    348,   352,   354,   356,   361,   365,   367,   369,   373,   374,
  230.    378,   380,   382,   384,   388,   390,   394,   396,   398,   400,
  231.    404,   406,   415,   424,   425,   426,   428,   432,   434,   436,
  232.    438,   440,   442,   444,   451,   452,   453,   456,   457,   466,
  233.    473,   480,   489,   491,   493,   495,   497,   499,   506,   509
  234. };
  235.  
  236. static const char * const yytname[] = {   "$",
  237. "error","$illegal.","IF","THEN","ELSE","ELIF","FI","CASE","ESAC","FOR",
  238. "WHILE","UNTIL","DO","DONE","FUNCTION","IN","BANG","WORD","NUMBER","AND_AND",
  239. "OR_OR","GREATER_GREATER","LESS_LESS","LESS_AND","GREATER_AND","SEMI_SEMI","LESS_LESS_MINUS","AND_GREATER","LESS_GREATER","GREATER_BAR",
  240. "'&'","';'","'\\n'","yacc_EOF","'|'","'>'","'<'","'-'","'{'","'}'",
  241. "'('","')'","inputunit","words","redirection","simple_command_element","redirections","simple_command","command","shell_command",
  242. "shell_command_1","if_command","group_command","elif_clause","case_clause_1","pattern_list_1","case_clause_sequence","pattern_list","pattern","list",
  243. "list0","list1","list_terminator","newlines","simple_list","simple_list1","pipeline",""
  244. };
  245. #endif
  246.  
  247. static const short yyr1[] = {     0,
  248.     43,    43,    43,    43,    44,    44,    45,    45,    45,    45,
  249.     45,    45,    45,    45,    45,    45,    45,    45,    45,    45,
  250.     45,    45,    45,    45,    45,    45,    45,    45,    45,    45,
  251.     45,    45,    45,    46,    46,    47,    47,    48,    48,    49,
  252.     49,    50,    50,    50,    51,    51,    51,    51,    51,    51,
  253.     51,    51,    51,    51,    51,    51,    51,    51,    51,    51,
  254.     51,    52,    52,    52,    53,    54,    54,    54,    55,    55,
  255.     56,    56,    56,    56,    57,    57,    58,    58,    58,    58,
  256.     59,    59,    60,    61,    61,    61,    61,    62,    62,    62,
  257.     62,    62,    62,    62,    63,    63,    63,    64,    64,    65,
  258.     65,    65,    66,    66,    66,    66,    66,    66,    67,    67
  259. };
  260.  
  261. static const short yyr2[] = {     0,
  262.      2,     1,     2,     1,     0,     2,     2,     2,     3,     3,
  263.      2,     3,     2,     3,     2,     3,     2,     3,     2,     3,
  264.      2,     3,     2,     3,     2,     3,     2,     3,     2,     3,
  265.      2,     2,     3,     1,     1,     1,     2,     1,     2,     1,
  266.      1,     1,     2,     2,     6,     6,     7,     7,    10,    10,
  267.      6,     7,     6,     1,     5,     5,     3,     1,     5,     6,
  268.      4,     5,     7,     6,     3,     4,     6,     5,     1,     2,
  269.      4,     4,     5,     5,     1,     2,     5,     5,     6,     6,
  270.      1,     3,     2,     1,     3,     3,     3,     4,     4,     4,
  271.      4,     4,     1,     2,     1,     1,     1,     0,     2,     1,
  272.      2,     2,     4,     4,     3,     3,     1,     2,     4,     1
  273. };
  274.  
  275. static const short yydefact[] = {     0,
  276.      0,    98,     0,     0,    98,    98,     0,     0,    34,     0,
  277.      0,     0,     0,     0,     0,     0,     0,     0,     2,     4,
  278.      0,     0,    98,    98,    35,    38,     0,    40,   110,    41,
  279.     42,    54,    58,     0,   100,   107,     3,     0,     0,    98,
  280.     98,     0,     0,    98,   108,     0,     0,     0,     0,     0,
  281.      0,     0,     0,     0,     0,    11,    13,    19,    15,    27,
  282.     21,    17,    25,    23,    29,    31,    32,     7,     8,     0,
  283.      0,     0,    37,    44,    34,    35,    39,    36,    43,     1,
  284.     98,    98,   101,   102,    98,    98,     0,    99,    83,    84,
  285.     93,     0,    98,     0,    98,    98,     0,     0,    98,    12,
  286.     14,    20,    16,    28,    22,    18,    26,    24,    30,    33,
  287.      9,    10,    65,    57,     0,     0,   105,   106,     0,     0,
  288.     94,    98,    98,    98,    98,    98,    98,     0,    98,     5,
  289.     98,     0,     0,    98,    61,     0,   103,   104,     0,     0,
  290.    109,    98,    98,    62,     0,     0,     0,    86,    87,    85,
  291.      0,    69,    98,    75,     0,    98,    98,     0,     0,     0,
  292.     55,    56,     0,    59,     0,     0,    64,    88,    89,    90,
  293.     91,    92,    53,    70,    76,     0,    51,    81,     0,     0,
  294.      0,     0,    45,     6,    96,    95,    97,    98,    46,    60,
  295.     63,    98,    98,    98,    98,    52,     0,     0,    98,    47,
  296.     48,     0,    66,     0,     0,     0,    98,    82,    71,    72,
  297.     98,    98,    98,    68,    73,    74,    77,    78,     0,     0,
  298.     67,    79,    80,    49,    50,     0,     0,     0
  299. };
  300.  
  301. static const short yydefgoto[] = {   226,
  302.    159,    25,    26,    27,    28,    29,    30,    31,    32,    33,
  303.    145,   151,   152,   153,   154,   180,    38,    89,    90,   188,
  304.     39,    34,   117,    91
  305. };
  306.  
  307. static const short yypact[] = {   202,
  308.    -18,-32768,     9,    23,-32768,-32768,    31,   394,    10,   466,
  309.     38,    44,    35,    56,    54,    74,    77,    87,-32768,-32768,
  310.     92,   100,-32768,-32768,    18,-32768,   426,   450,-32768,-32768,
  311.     84,-32768,-32768,    86,    96,    88,-32768,   118,   266,-32768,
  312.    102,   135,   136,   121,    88,   128,   145,   154,    61,    64,
  313.    158,   159,   170,   172,   173,-32768,-32768,-32768,-32768,-32768,
  314. -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,   160,
  315.    157,    10,-32768,-32768,-32768,-32768,-32768,-32768,    84,-32768,
  316. -32768,-32768,   330,   330,-32768,-32768,   394,-32768,-32768,   111,
  317.     88,     1,-32768,    19,-32768,-32768,   162,     7,-32768,-32768,
  318. -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
  319. -32768,-32768,-32768,-32768,   298,   298,     3,     3,   362,   140,
  320.     88,-32768,-32768,-32768,-32768,-32768,-32768,    -8,-32768,-32768,
  321. -32768,   182,   184,-32768,-32768,     7,-32768,-32768,   330,   330,
  322.     88,-32768,-32768,-32768,   194,   266,   266,   266,   266,   266,
  323.    200,-32768,-32768,-32768,    27,-32768,-32768,   197,   107,   175,
  324. -32768,-32768,     7,-32768,   209,   214,-32768,-32768,-32768,    17,
  325.     17,    17,-32768,-32768,-32768,    30,-32768,-32768,   204,    58,
  326.    219,   183,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
  327. -32768,-32768,-32768,-32768,-32768,-32768,   123,   210,-32768,-32768,
  328. -32768,    37,    72,   266,   266,   266,-32768,-32768,   208,   156,
  329. -32768,-32768,-32768,-32768,   221,   234,-32768,-32768,   226,   215,
  330. -32768,-32768,-32768,-32768,-32768,   248,   250,-32768
  331. };
  332.  
  333. static const short yypgoto[] = {-32768,
  334. -32768,   -15,   237,   223,-32768,-32768,-32768,   239,-32768,   -94,
  335.     65,-32768,   119,-32768,   126,   101,    -5,-32768,  -139,-32768,
  336.    -38,-32768,    20,    14
  337. };
  338.  
  339.  
  340. #define    YYLAST        503
  341.  
  342.  
  343. static const short yytable[] = {    42,
  344.     43,    92,    94,   135,   156,    98,   168,   169,   170,   171,
  345.    172,    73,    76,    36,    37,    78,   127,    70,    71,    35,
  346.    -36,    45,    81,    82,    88,   -36,    40,   -36,   -36,   -36,
  347.    157,   129,   -36,    88,   130,   177,   122,   123,   196,    88,
  348.     41,   164,   115,   116,   178,    23,   119,   178,    44,   211,
  349.     46,    88,    58,    59,   128,    56,   -36,   131,   -36,    88,
  350.    136,    57,    88,    73,   170,   171,   172,   179,   190,    88,
  351.    179,    64,    60,    61,    62,   212,   213,   143,   102,   103,
  352.    120,   105,   106,   146,   147,   148,   149,   150,   155,   132,
  353.    133,    65,   198,    63,    66,   163,    36,    36,   104,   199,
  354.    121,   107,    10,   118,    67,    11,    12,    13,    14,    68,
  355.     15,    16,    17,    18,   176,    81,    82,    69,    80,    21,
  356.     22,    86,    85,   158,   184,   160,    83,    84,    36,    36,
  357.    122,   123,   141,    93,   137,   138,   165,   166,   185,   186,
  358.    187,   124,   125,   126,   142,   143,   144,    95,    96,   202,
  359.    181,   182,    36,    36,   204,   205,   206,   198,     2,   118,
  360.    210,    97,   100,     3,   207,     4,     5,     6,   216,    99,
  361.      7,   101,    87,     9,    10,   108,   109,    11,    12,    13,
  362.     14,   218,    15,    16,    17,    18,   203,   110,    88,   111,
  363.    112,    21,    22,   209,    23,   161,    24,   162,   114,   113,
  364.    167,   215,     1,   134,     2,   219,   220,   221,   173,     3,
  365.    183,     4,     5,     6,   189,   191,     7,   192,     8,     9,
  366.     10,   178,   201,    11,    12,    13,    14,   208,    15,    16,
  367.     17,    18,   200,   217,    19,    20,     2,    21,    22,   224,
  368.     23,     3,    24,     4,     5,     6,   222,   227,     7,   228,
  369.     87,     9,    10,    79,   225,    11,    12,    13,    14,   223,
  370.     15,    16,    17,    18,    77,    74,    88,   214,     2,    21,
  371.     22,   174,    23,     3,    24,     4,     5,     6,   175,   197,
  372.      7,     0,    87,     9,    10,     0,     0,    11,    12,    13,
  373.     14,     0,    15,    16,    17,    18,     0,     0,    88,     0,
  374.      2,    21,    22,     0,    23,     3,    24,     4,     5,     6,
  375.      0,     0,     7,     0,     8,     9,    10,     0,     0,    11,
  376.     12,    13,    14,     0,    15,    16,    17,    18,     0,     0,
  377.     88,     0,     2,    21,    22,     0,    23,     3,    24,     4,
  378.      5,     6,     0,     0,     7,     0,     8,     9,    10,     0,
  379.      0,    11,    12,    13,    14,     0,    15,    16,    17,    18,
  380.      0,     0,     0,     0,     2,    21,    22,     0,    23,     3,
  381.     24,     4,     5,     6,     0,     0,     7,     0,     0,     9,
  382.     10,     0,     0,    11,    12,    13,    14,     0,    15,    16,
  383.     17,    18,     0,     0,    88,     0,     2,    21,    22,     0,
  384.     23,     3,    24,     4,     5,     6,     0,     0,     7,     0,
  385.      0,     9,    10,     0,     0,    11,    12,    13,    14,     0,
  386.     15,    16,    17,    18,     0,     0,     0,     0,     2,    21,
  387.     22,     0,    23,     3,    24,     4,     5,     6,     0,     0,
  388.      7,     0,     0,    72,    10,     0,     0,    11,    12,    13,
  389.     14,     0,    15,    16,    17,    18,     0,     0,     0,     0,
  390.      0,    21,    22,     0,    23,     0,    24,    75,    10,     0,
  391.      0,    11,    12,    13,    14,     0,    15,    16,    17,    18,
  392.      0,     0,     0,     0,     0,    21,    22,    47,    48,    49,
  393.     50,     0,    51,     0,    52,    53,     0,     0,     0,     0,
  394.      0,    54,    55
  395. };
  396.  
  397. static const short yycheck[] = {     5,
  398.      6,    40,    41,    98,    13,    44,   146,   147,   148,   149,
  399.    150,    27,    28,     0,    33,    31,    16,    23,    24,     0,
  400.      3,     8,    20,    21,    33,     8,    18,    10,    11,    12,
  401.     39,    13,    15,    33,    16,     9,    20,    21,     9,    33,
  402.     18,   136,    81,    82,    18,    39,    85,    18,    18,    13,
  403.     41,    33,    18,    19,    93,    18,    39,    39,    41,    33,
  404.     99,    18,    33,    79,   204,   205,   206,    41,   163,    33,
  405.     41,    18,    38,    18,    19,    39,     5,     6,    18,    19,
  406.     86,    18,    19,   122,   123,   124,   125,   126,   127,    95,
  407.     96,    18,    35,    38,    18,   134,    83,    84,    38,    42,
  408.     87,    38,    19,    84,    18,    22,    23,    24,    25,    18,
  409.     27,    28,    29,    30,   153,    20,    21,    18,    33,    36,
  410.     37,     4,    35,   129,    18,   131,    31,    32,   115,   116,
  411.     20,    21,   119,    32,   115,   116,   142,   143,    32,    33,
  412.     34,    31,    32,    33,     5,     6,     7,    13,    13,   188,
  413.    156,   157,   139,   140,   193,   194,   195,    35,     3,   140,
  414.    199,    41,    18,     8,    42,    10,    11,    12,   207,    42,
  415.     15,    18,    17,    18,    19,    18,    18,    22,    23,    24,
  416.     25,    26,    27,    28,    29,    30,   192,    18,    33,    18,
  417.     18,    36,    37,   199,    39,    14,    41,    14,    42,    40,
  418.      7,   207,     1,    42,     3,   211,   212,   213,     9,     8,
  419.     14,    10,    11,    12,    40,     7,    15,     4,    17,    18,
  420.     19,    18,    40,    22,    23,    24,    25,    18,    27,    28,
  421.     29,    30,    14,    26,    33,    34,     3,    36,    37,    14,
  422.     39,     8,    41,    10,    11,    12,    26,     0,    15,     0,
  423.     17,    18,    19,    31,    40,    22,    23,    24,    25,    26,
  424.     27,    28,    29,    30,    28,    27,    33,   203,     3,    36,
  425.     37,   153,    39,     8,    41,    10,    11,    12,   153,   179,
  426.     15,    -1,    17,    18,    19,    -1,    -1,    22,    23,    24,
  427.     25,    -1,    27,    28,    29,    30,    -1,    -1,    33,    -1,
  428.      3,    36,    37,    -1,    39,     8,    41,    10,    11,    12,
  429.     -1,    -1,    15,    -1,    17,    18,    19,    -1,    -1,    22,
  430.     23,    24,    25,    -1,    27,    28,    29,    30,    -1,    -1,
  431.     33,    -1,     3,    36,    37,    -1,    39,     8,    41,    10,
  432.     11,    12,    -1,    -1,    15,    -1,    17,    18,    19,    -1,
  433.     -1,    22,    23,    24,    25,    -1,    27,    28,    29,    30,
  434.     -1,    -1,    -1,    -1,     3,    36,    37,    -1,    39,     8,
  435.     41,    10,    11,    12,    -1,    -1,    15,    -1,    -1,    18,
  436.     19,    -1,    -1,    22,    23,    24,    25,    -1,    27,    28,
  437.     29,    30,    -1,    -1,    33,    -1,     3,    36,    37,    -1,
  438.     39,     8,    41,    10,    11,    12,    -1,    -1,    15,    -1,
  439.     -1,    18,    19,    -1,    -1,    22,    23,    24,    25,    -1,
  440.     27,    28,    29,    30,    -1,    -1,    -1,    -1,     3,    36,
  441.     37,    -1,    39,     8,    41,    10,    11,    12,    -1,    -1,
  442.     15,    -1,    -1,    18,    19,    -1,    -1,    22,    23,    24,
  443.     25,    -1,    27,    28,    29,    30,    -1,    -1,    -1,    -1,
  444.     -1,    36,    37,    -1,    39,    -1,    41,    18,    19,    -1,
  445.     -1,    22,    23,    24,    25,    -1,    27,    28,    29,    30,
  446.     -1,    -1,    -1,    -1,    -1,    36,    37,    22,    23,    24,
  447.     25,    -1,    27,    -1,    29,    30,    -1,    -1,    -1,    -1,
  448.     -1,    36,    37
  449. };
  450. /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
  451. #line 3 "/usr/gnu/lib/bison.simple"
  452.  
  453. /* Skeleton output parser for bison,
  454.    Copyright (C) 1984, 1989, 1990 Bob Corbett and Richard Stallman
  455.  
  456.    This program is free software; you can redistribute it and/or modify
  457.    it under the terms of the GNU General Public License as published by
  458.    the Free Software Foundation; either version 1, or (at your option)
  459.    any later version.
  460.  
  461.    This program is distributed in the hope that it will be useful,
  462.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  463.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  464.    GNU General Public License for more details.
  465.  
  466.    You should have received a copy of the GNU General Public License
  467.    along with this program; if not, write to the Free Software
  468.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  469.  
  470.  
  471. #ifndef alloca
  472. #ifdef __GNUC__
  473. #define alloca __builtin_alloca
  474. #else /* Not GNU C.  */
  475. #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__)
  476. #include <alloca.h>
  477. #else /* Not sparc */
  478. #ifdef MSDOS
  479. #include <malloc.h>
  480. #endif /* MSDOS */
  481. #endif /* Not sparc.  */
  482. #endif /* Not GNU C.  */
  483. #endif /* alloca not defined.  */
  484.  
  485. /* This is the parser code that is written into each bison parser
  486.   when the %semantic_parser declaration is not specified in the grammar.
  487.   It was written by Richard Stallman by simplifying the hairy parser
  488.   used when %semantic_parser is specified.  */
  489.  
  490. /* Note: there must be only one dollar sign in this file.
  491.    It is replaced by the list of actions, each action
  492.    as one case of the switch.  */
  493.  
  494. #define yyerrok        (yyerrstatus = 0)
  495. #define yyclearin    (yychar = YYEMPTY)
  496. #define YYEMPTY        -2
  497. #define YYEOF        0
  498. #define YYACCEPT    return(0)
  499. #define YYABORT     return(1)
  500. #define YYERROR        goto yyerrlab1
  501. /* Like YYERROR except do call yyerror.
  502.    This remains here temporarily to ease the
  503.    transition to the new meaning of YYERROR, for GCC.
  504.    Once GCC version 2 has supplanted version 1, this can go.  */
  505. #define YYFAIL        goto yyerrlab
  506. #define YYRECOVERING()  (!!yyerrstatus)
  507. #define YYBACKUP(token, value) \
  508. do                                \
  509.   if (yychar == YYEMPTY && yylen == 1)                \
  510.     { yychar = (token), yylval = (value);            \
  511.       yychar1 = YYTRANSLATE (yychar);                \
  512.       YYPOPSTACK;                        \
  513.       goto yybackup;                        \
  514.     }                                \
  515.   else                                \
  516.     { yyerror ("syntax error: cannot back up"); YYERROR; }    \
  517. while (0)
  518.  
  519. #define YYTERROR    1
  520. #define YYERRCODE    256
  521.  
  522. #ifndef YYPURE
  523. #define YYLEX        yylex()
  524. #endif
  525.  
  526. #ifdef YYPURE
  527. #ifdef YYLSP_NEEDED
  528. #define YYLEX        yylex(&yylval, &yylloc)
  529. #else
  530. #define YYLEX        yylex(&yylval)
  531. #endif
  532. #endif
  533.  
  534. /* If nonreentrant, generate the variables here */
  535.  
  536. #ifndef YYPURE
  537.  
  538. int    yychar;            /*  the lookahead symbol        */
  539. YYSTYPE    yylval;            /*  the semantic value of the        */
  540.                 /*  lookahead symbol            */
  541.  
  542. #ifdef YYLSP_NEEDED
  543. YYLTYPE yylloc;            /*  location data for the lookahead    */
  544.                 /*  symbol                */
  545. #endif
  546.  
  547. int yynerrs;            /*  number of parse errors so far       */
  548. #endif  /* not YYPURE */
  549.  
  550. #if YYDEBUG != 0
  551. int yydebug;            /*  nonzero means print parse trace    */
  552. /* Since this is uninitialized, it does not stop multiple parsers
  553.    from coexisting.  */
  554. #endif
  555.  
  556. /*  YYINITDEPTH indicates the initial size of the parser's stacks    */
  557.  
  558. #ifndef    YYINITDEPTH
  559. #define YYINITDEPTH 200
  560. #endif
  561.  
  562. /*  YYMAXDEPTH is the maximum size the stacks can grow to
  563.     (effective only if the built-in stack extension method is used).  */
  564.  
  565. #if YYMAXDEPTH == 0
  566. #undef YYMAXDEPTH
  567. #endif
  568.  
  569. #ifndef YYMAXDEPTH
  570. #define YYMAXDEPTH 10000
  571. #endif
  572.  
  573. #ifndef __cplusplus
  574.  
  575. /* This is the most reliable way to avoid incompatibilities
  576.    in available built-in functions on various systems.  */
  577. static void
  578. __yy_bcopy (from, to, count)
  579.      char *from;
  580.      char *to;
  581.      int count;
  582. {
  583.   register char *f = from;
  584.   register char *t = to;
  585.   register int i = count;
  586.  
  587.   while (i-- > 0)
  588.     *t++ = *f++;
  589. }
  590.  
  591. #else /* __cplusplus */
  592.  
  593. /* This is the most reliable way to avoid incompatibilities
  594.    in available built-in functions on various systems.  */
  595. static void
  596. __yy_bcopy (char *from, char *to, int count)
  597. {
  598.   register char *f = from;
  599.   register char *t = to;
  600.   register int i = count;
  601.  
  602.   while (i-- > 0)
  603.     *t++ = *f++;
  604. }
  605.  
  606. #endif
  607.  
  608. #line 160 "/usr/gnu/lib/bison.simple"
  609. int
  610. yyparse()
  611. {
  612.   register int yystate;
  613.   register int yyn;
  614.   register short *yyssp;
  615.   register YYSTYPE *yyvsp;
  616.   int yyerrstatus;    /*  number of tokens to shift before error messages enabled */
  617.   int yychar1;        /*  lookahead token as an internal (translated) token number */
  618.  
  619.   short    yyssa[YYINITDEPTH];    /*  the state stack            */
  620.   YYSTYPE yyvsa[YYINITDEPTH];    /*  the semantic value stack        */
  621.  
  622.   short *yyss = yyssa;        /*  refer to the stacks thru separate pointers */
  623.   YYSTYPE *yyvs = yyvsa;    /*  to allow yyoverflow to reallocate them elsewhere */
  624.  
  625. #ifdef YYLSP_NEEDED
  626.   YYLTYPE *yyls = yylsa;
  627.   YYLTYPE *yylsp;
  628.   YYLTYPE yylsa[YYINITDEPTH];    /*  the location stack            */
  629.  
  630. #define YYPOPSTACK   (yyvsp--, yysp--, yylsp--)
  631. #else
  632. #define YYPOPSTACK   (yyvsp--, yysp--)
  633. #endif
  634.  
  635.   int yystacksize = YYINITDEPTH;
  636.  
  637. #ifdef YYPURE
  638.   int yychar;
  639.   YYSTYPE yylval;
  640.   int yynerrs;
  641. #ifdef YYLSP_NEEDED
  642.   YYLTYPE yylloc;
  643. #endif
  644. #endif
  645.  
  646.   YYSTYPE yyval;        /*  the variable used to return        */
  647.                 /*  semantic values from the action    */
  648.                 /*  routines                */
  649.  
  650.   int yylen;
  651.  
  652. #if YYDEBUG != 0
  653.   if (yydebug)
  654.     fprintf(stderr, "Starting parse\n");
  655. #endif
  656.  
  657.   yystate = 0;
  658.   yyerrstatus = 0;
  659.   yynerrs = 0;
  660.   yychar = YYEMPTY;        /* Cause a token to be read.  */
  661.  
  662.   /* Initialize stack pointers.
  663.      Waste one element of value and location stack
  664.      so that they stay on the same level as the state stack.  */
  665.  
  666.   yyssp = yyss - 1;
  667.   yyvsp = yyvs;
  668. #ifdef YYLSP_NEEDED
  669.   yylsp = yyls;
  670. #endif
  671.  
  672. /* Push a new state, which is found in  yystate  .  */
  673. /* In all cases, when you get here, the value and location stacks
  674.    have just been pushed. so pushing a state here evens the stacks.  */
  675. yynewstate:
  676.  
  677.   *++yyssp = yystate;
  678.  
  679.   if (yyssp >= yyss + yystacksize - 1)
  680.     {
  681.       /* Give user a chance to reallocate the stack */
  682.       /* Use copies of these so that the &'s don't force the real ones into memory. */
  683.       YYSTYPE *yyvs1 = yyvs;
  684.       short *yyss1 = yyss;
  685. #ifdef YYLSP_NEEDED
  686.       YYLTYPE *yyls1 = yyls;
  687. #endif
  688.  
  689.       /* Get the current used size of the three stacks, in elements.  */
  690.       int size = yyssp - yyss + 1;
  691.  
  692. #ifdef yyoverflow
  693.       /* Each stack pointer address is followed by the size of
  694.      the data in use in that stack, in bytes.  */
  695.       yyoverflow("parser stack overflow",
  696.          &yyss1, size * sizeof (*yyssp),
  697.          &yyvs1, size * sizeof (*yyvsp),
  698. #ifdef YYLSP_NEEDED
  699.          &yyls1, size * sizeof (*yylsp),
  700. #endif
  701.          &yystacksize);
  702.  
  703.       yyss = yyss1; yyvs = yyvs1;
  704. #ifdef YYLSP_NEEDED
  705.       yyls = yyls1;
  706. #endif
  707. #else /* no yyoverflow */
  708.       /* Extend the stack our own way.  */
  709.       if (yystacksize >= YYMAXDEPTH)
  710.     {
  711.       yyerror("parser stack overflow");
  712.       return 2;
  713.     }
  714.       yystacksize *= 2;
  715.       if (yystacksize > YYMAXDEPTH)
  716.     yystacksize = YYMAXDEPTH;
  717.       yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
  718.       __yy_bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
  719.       yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
  720.       __yy_bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
  721. #ifdef YYLSP_NEEDED
  722.       yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
  723.       __yy_bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
  724. #endif
  725. #endif /* no yyoverflow */
  726.  
  727.       yyssp = yyss + size - 1;
  728.       yyvsp = yyvs + size - 1;
  729. #ifdef YYLSP_NEEDED
  730.       yylsp = yyls + size - 1;
  731. #endif
  732.  
  733. #if YYDEBUG != 0
  734.       if (yydebug)
  735.     fprintf(stderr, "Stack size increased to %d\n", yystacksize);
  736. #endif
  737.  
  738.       if (yyssp >= yyss + yystacksize - 1)
  739.     YYABORT;
  740.     }
  741.  
  742. #if YYDEBUG != 0
  743.   if (yydebug)
  744.     fprintf(stderr, "Entering state %d\n", yystate);
  745. #endif
  746.  
  747.  yybackup:
  748.  
  749. /* Do appropriate processing given the current state.  */
  750. /* Read a lookahead token if we need one and don't already have one.  */
  751. /* yyresume: */
  752.  
  753.   /* First try to decide what to do without reference to lookahead token.  */
  754.  
  755.   yyn = yypact[yystate];
  756.   if (yyn == YYFLAG)
  757.     goto yydefault;
  758.  
  759.   /* Not known => get a lookahead token if don't already have one.  */
  760.  
  761.   /* yychar is either YYEMPTY or YYEOF
  762.      or a valid token in external form.  */
  763.  
  764.   if (yychar == YYEMPTY)
  765.     {
  766. #if YYDEBUG != 0
  767.       if (yydebug)
  768.     fprintf(stderr, "Reading a token: ");
  769. #endif
  770.       yychar = YYLEX;
  771.     }
  772.  
  773.   /* Convert token to internal form (in yychar1) for indexing tables with */
  774.  
  775.   if (yychar <= 0)        /* This means end of input. */
  776.     {
  777.       yychar1 = 0;
  778.       yychar = YYEOF;        /* Don't call YYLEX any more */
  779.  
  780. #if YYDEBUG != 0
  781.       if (yydebug)
  782.     fprintf(stderr, "Now at end of input.\n");
  783. #endif
  784.     }
  785.   else
  786.     {
  787.       yychar1 = YYTRANSLATE(yychar);
  788.  
  789. #if YYDEBUG != 0
  790.       if (yydebug)
  791.     fprintf(stderr, "Next token is %d (%s)\n", yychar, yytname[yychar1]);
  792. #endif
  793.     }
  794.  
  795.   yyn += yychar1;
  796.   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
  797.     goto yydefault;
  798.  
  799.   yyn = yytable[yyn];
  800.  
  801.   /* yyn is what to do for this token type in this state.
  802.      Negative => reduce, -yyn is rule number.
  803.      Positive => shift, yyn is new state.
  804.        New state is final state => don't bother to shift,
  805.        just return success.
  806.      0, or most negative number => error.  */
  807.  
  808.   if (yyn < 0)
  809.     {
  810.       if (yyn == YYFLAG)
  811.     goto yyerrlab;
  812.       yyn = -yyn;
  813.       goto yyreduce;
  814.     }
  815.   else if (yyn == 0)
  816.     goto yyerrlab;
  817.  
  818.   if (yyn == YYFINAL)
  819.     YYACCEPT;
  820.  
  821.   /* Shift the lookahead token.  */
  822.  
  823. #if YYDEBUG != 0
  824.   if (yydebug)
  825.     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
  826. #endif
  827.  
  828.   /* Discard the token being shifted unless it is eof.  */
  829.   if (yychar != YYEOF)
  830.     yychar = YYEMPTY;
  831.  
  832.   *++yyvsp = yylval;
  833. #ifdef YYLSP_NEEDED
  834.   *++yylsp = yylloc;
  835. #endif
  836.  
  837.   /* count tokens shifted since error; after three, turn off error status.  */
  838.   if (yyerrstatus) yyerrstatus--;
  839.  
  840.   yystate = yyn;
  841.   goto yynewstate;
  842.  
  843. /* Do the default action for the current state.  */
  844. yydefault:
  845.  
  846.   yyn = yydefact[yystate];
  847.   if (yyn == 0)
  848.     goto yyerrlab;
  849.  
  850. /* Do a reduction.  yyn is the number of a rule to reduce with.  */
  851. yyreduce:
  852.   yylen = yyr2[yyn];
  853.   yyval = yyvsp[1-yylen]; /* implement default value of the action */
  854.  
  855. #if YYDEBUG != 0
  856.   if (yydebug)
  857.     {
  858.       int i;
  859.  
  860.       fprintf (stderr, "Reducing via rule %d (line %d), ",
  861.            yyn, yyrline[yyn]);
  862.  
  863.       /* Print the symboles being reduced, and their result.  */
  864.       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
  865.     fprintf (stderr, "%s ", yytname[yyrhs[i]]);
  866.       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
  867.     }
  868. #endif
  869.  
  870.  
  871.   switch (yyn) {
  872.  
  873. case 1:
  874. #line 115 "parse.y"
  875. {
  876.               /* Case of regular command.  Discard the error
  877.                  safety net,and return the command just parsed. */
  878.               global_command = yyvsp[-1].command;
  879.               eof_encountered = 0;
  880.               discard_parser_constructs (0);
  881.               YYACCEPT;
  882.             ;
  883.     break;}
  884. case 2:
  885. #line 124 "parse.y"
  886. {
  887.               /* Case of regular command, but not a very
  888.                  interesting one.  Return a NULL command. */
  889.               global_command = (COMMAND *)NULL;
  890.               YYACCEPT;
  891.             ;
  892.     break;}
  893. case 3:
  894. #line 132 "parse.y"
  895. {
  896.               /* Error during parsing.  Return NULL command. */
  897.               global_command = (COMMAND *)NULL;
  898.               eof_encountered = 0;
  899.               discard_parser_constructs (1);
  900.               if (interactive)
  901.                 {
  902.                   YYACCEPT;
  903.                 }
  904.               else
  905.                 {
  906.                   YYABORT;
  907.                 }
  908.             ;
  909.     break;}
  910. case 4:
  911. #line 147 "parse.y"
  912. {
  913.               /* Case of EOF seen by itself.  Do ignoreeof or 
  914.                  not. */
  915.               global_command = (COMMAND *)NULL;
  916.               handle_eof_input_unit ();
  917.               YYACCEPT;
  918.             ;
  919.     break;}
  920. case 5:
  921. #line 157 "parse.y"
  922. { yyval.word_list = (WORD_LIST *)NULL; ;
  923.     break;}
  924. case 6:
  925. #line 159 "parse.y"
  926. { yyval.word_list = make_word_list (yyvsp[0].word, yyvsp[-1].word_list); ;
  927.     break;}
  928. case 7:
  929. #line 163 "parse.y"
  930. { yyval.redirect = make_redirection ( 1, r_output_direction, yyvsp[0].word); ;
  931.     break;}
  932. case 8:
  933. #line 165 "parse.y"
  934. { yyval.redirect = make_redirection ( 0, r_input_direction, yyvsp[0].word); ;
  935.     break;}
  936. case 9:
  937. #line 167 "parse.y"
  938. { yyval.redirect = make_redirection (yyvsp[-2].number, r_output_direction, yyvsp[0].word); ;
  939.     break;}
  940. case 10:
  941. #line 169 "parse.y"
  942. { yyval.redirect = make_redirection (yyvsp[-2].number, r_input_direction, yyvsp[0].word); ;
  943.     break;}
  944. case 11:
  945. #line 171 "parse.y"
  946. { yyval.redirect = make_redirection ( 1, r_appending_to, yyvsp[0].word); ;
  947.     break;}
  948. case 12:
  949. #line 173 "parse.y"
  950. { yyval.redirect = make_redirection (yyvsp[-2].number, r_appending_to, yyvsp[0].word); ;
  951.     break;}
  952. case 13:
  953. #line 175 "parse.y"
  954. {
  955.               yyval.redirect = make_redirection ( 0, r_reading_until, yyvsp[0].word);
  956.               redirection_needing_here_doc = yyval.redirect;
  957.               need_here_doc = 1;
  958.             ;
  959.     break;}
  960. case 14:
  961. #line 181 "parse.y"
  962. {
  963.               yyval.redirect = make_redirection (yyvsp[-2].number, r_reading_until, yyvsp[0].word);
  964.               redirection_needing_here_doc = yyval.redirect;
  965.               need_here_doc = 1;
  966.             ;
  967.     break;}
  968. case 15:
  969. #line 187 "parse.y"
  970. {
  971.               yyval.redirect = make_redirection ( 0, r_duplicating_input, yyvsp[0].number);
  972.             ;
  973.     break;}
  974. case 16:
  975. #line 191 "parse.y"
  976. {
  977.               yyval.redirect = make_redirection (yyvsp[-2].number, r_duplicating_input, yyvsp[0].number);
  978.             ;
  979.     break;}
  980. case 17:
  981. #line 195 "parse.y"
  982. {
  983.               yyval.redirect = make_redirection ( 1, r_duplicating_output, yyvsp[0].number);
  984.             ;
  985.     break;}
  986. case 18:
  987. #line 199 "parse.y"
  988. {
  989.               yyval.redirect = make_redirection (yyvsp[-2].number, r_duplicating_output, yyvsp[0].number);
  990.             ;
  991.     break;}
  992. case 19:
  993. #line 203 "parse.y"
  994. {
  995.               yyval.redirect = make_redirection
  996.                 (0, r_duplicating_input_word, yyvsp[0].word);
  997.             ;
  998.     break;}
  999. case 20:
  1000. #line 208 "parse.y"
  1001. {
  1002.               yyval.redirect = make_redirection
  1003.                 (yyvsp[-2].number, r_duplicating_input_word, yyvsp[0].word);
  1004.             ;
  1005.     break;}
  1006. case 21:
  1007. #line 213 "parse.y"
  1008. {
  1009.               yyval.redirect = make_redirection
  1010.                 (1, r_duplicating_output_word, yyvsp[0].word);
  1011.             ;
  1012.     break;}
  1013. case 22:
  1014. #line 218 "parse.y"
  1015. {
  1016.               yyval.redirect = make_redirection
  1017.                 (yyvsp[-2].number, r_duplicating_output_word, yyvsp[0].word);
  1018.             ;
  1019.     break;}
  1020. case 23:
  1021. #line 223 "parse.y"
  1022. {
  1023.               yyval.redirect = make_redirection
  1024.                 (0, r_deblank_reading_until, yyvsp[0].word);
  1025.               redirection_needing_here_doc = yyval.redirect;
  1026.               need_here_doc = 1;
  1027.             ;
  1028.     break;}
  1029. case 24:
  1030. #line 230 "parse.y"
  1031. {
  1032.               yyval.redirect = make_redirection
  1033.                 (yyvsp[-2].number, r_deblank_reading_until, yyvsp[0].word);
  1034.               redirection_needing_here_doc = yyval.redirect;
  1035.               need_here_doc = 1;
  1036.             ;
  1037.     break;}
  1038. case 25:
  1039. #line 237 "parse.y"
  1040. { yyval.redirect = make_redirection ( 1, r_close_this, 0); ;
  1041.     break;}
  1042. case 26:
  1043. #line 239 "parse.y"
  1044. { yyval.redirect = make_redirection (yyvsp[-2].number, r_close_this, 0); ;
  1045.     break;}
  1046. case 27:
  1047. #line 241 "parse.y"
  1048. { yyval.redirect = make_redirection ( 0, r_close_this, 0); ;
  1049.     break;}
  1050. case 28:
  1051. #line 243 "parse.y"
  1052. { yyval.redirect = make_redirection (yyvsp[-2].number, r_close_this, 0); ;
  1053.     break;}
  1054. case 29:
  1055. #line 245 "parse.y"
  1056. { yyval.redirect = make_redirection ( 1, r_err_and_out, yyvsp[0].word); ;
  1057.     break;}
  1058. case 30:
  1059. #line 247 "parse.y"
  1060. { yyval.redirect = make_redirection ( yyvsp[-2].number, r_input_output, yyvsp[0].word); ;
  1061.     break;}
  1062. case 31:
  1063. #line 249 "parse.y"
  1064. {
  1065.               REDIRECT *t1, *t2;
  1066.               extern WORD_DESC *copy_word ();
  1067.  
  1068.               t1 = make_redirection ( 0, r_input_direction, yyvsp[0].word);
  1069.               t2 = make_redirection ( 1, r_output_direction, copy_word (yyvsp[0].word));
  1070.               t1->next = t2;
  1071.               yyval.redirect = t1;
  1072.             ;
  1073.     break;}
  1074. case 32:
  1075. #line 259 "parse.y"
  1076. { yyval.redirect = make_redirection ( 1, r_output_force, yyvsp[0].word); ;
  1077.     break;}
  1078. case 33:
  1079. #line 261 "parse.y"
  1080. { yyval.redirect = make_redirection ( yyvsp[-2].number, r_output_force, yyvsp[0].word); ;
  1081.     break;}
  1082. case 34:
  1083. #line 265 "parse.y"
  1084. { yyval.element.word = yyvsp[0].word; yyval.element.redirect = 0; ;
  1085.     break;}
  1086. case 35:
  1087. #line 267 "parse.y"
  1088. { yyval.element.redirect = yyvsp[0].redirect; yyval.element.word = 0; ;
  1089.     break;}
  1090. case 36:
  1091. #line 271 "parse.y"
  1092. {
  1093.               yyval.redirect = yyvsp[0].redirect;
  1094.             ;
  1095.     break;}
  1096. case 37:
  1097. #line 275 "parse.y"
  1098. { 
  1099.               register REDIRECT *t = yyvsp[-1].redirect;
  1100.  
  1101.               while (t->next)
  1102.                 t = t->next;
  1103.               t->next = yyvsp[0].redirect; 
  1104.               yyval.redirect = yyvsp[-1].redirect;
  1105.             ;
  1106.     break;}
  1107. case 38:
  1108. #line 286 "parse.y"
  1109. { yyval.command = make_simple_command (yyvsp[0].element, (COMMAND *)NULL); ;
  1110.     break;}
  1111. case 39:
  1112. #line 288 "parse.y"
  1113. { yyval.command = make_simple_command (yyvsp[0].element, yyvsp[-1].command); ;
  1114.     break;}
  1115. case 40:
  1116. #line 292 "parse.y"
  1117. { yyval.command = clean_simple_command (yyvsp[0].command); ;
  1118.     break;}
  1119. case 41:
  1120. #line 294 "parse.y"
  1121. { yyval.command = yyvsp[0].command; ;
  1122.     break;}
  1123. case 42:
  1124. #line 298 "parse.y"
  1125. { yyval.command = yyvsp[0].command; ;
  1126.     break;}
  1127. case 43:
  1128. #line 300 "parse.y"
  1129. { yyvsp[-1].command->redirects = yyvsp[0].redirect; yyval.command = yyvsp[-1].command; ;
  1130.     break;}
  1131. case 44:
  1132. #line 303 "parse.y"
  1133. { yyvsp[0].command->redirects = yyvsp[-1].redirect; yyval.command = yyvsp[0].command; ;
  1134.     break;}
  1135. case 45:
  1136. #line 307 "parse.y"
  1137. { yyval.command = make_for_command (yyvsp[-4].word, (WORD_LIST *)add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command); ;
  1138.     break;}
  1139. case 46:
  1140. #line 309 "parse.y"
  1141. { yyval.command = make_for_command (yyvsp[-4].word, (WORD_LIST *)add_string_to_list ("$@", (WORD_LIST *)NULL), yyvsp[-1].command); ;
  1142.     break;}
  1143. case 47:
  1144. #line 311 "parse.y"
  1145. { yyval.command = make_for_command (yyvsp[-5].word, (WORD_LIST *)add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command); ;
  1146.     break;}
  1147. case 48:
  1148. #line 313 "parse.y"
  1149. { yyval.command = make_for_command (yyvsp[-5].word, (WORD_LIST *)add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command); ;
  1150.     break;}
  1151. case 49:
  1152. #line 316 "parse.y"
  1153. { yyval.command = make_for_command (yyvsp[-8].word, (WORD_LIST *)reverse_list (yyvsp[-5].word_list), yyvsp[-1].command); ;
  1154.     break;}
  1155. case 50:
  1156. #line 318 "parse.y"
  1157. { yyval.command = make_for_command (yyvsp[-8].word, (WORD_LIST *)reverse_list (yyvsp[-5].word_list), yyvsp[-1].command); ;
  1158.     break;}
  1159. case 51:
  1160. #line 321 "parse.y"
  1161. { yyval.command = make_case_command (yyvsp[-4].word, (PATTERN_LIST *)NULL); ;
  1162.     break;}
  1163. case 52:
  1164. #line 323 "parse.y"
  1165. { yyval.command = make_case_command (yyvsp[-5].word, yyvsp[-2].pattern); ;
  1166.     break;}
  1167. case 53:
  1168. #line 325 "parse.y"
  1169. { /* Nobody likes this...
  1170.                  report_syntax_error ("Inserted `;;'"); */
  1171.               yyval.command = make_case_command (yyvsp[-4].word, yyvsp[-1].pattern); ;
  1172.     break;}
  1173. case 54:
  1174. #line 330 "parse.y"
  1175. { yyval.command = yyvsp[0].command; ;
  1176.     break;}
  1177. case 55:
  1178. #line 332 "parse.y"
  1179. { yyval.command = make_while_command (yyvsp[-3].command, yyvsp[-1].command); ;
  1180.     break;}
  1181. case 56:
  1182. #line 334 "parse.y"
  1183. { yyval.command = make_until_command (yyvsp[-3].command, yyvsp[-1].command); ;
  1184.     break;}
  1185. case 57:
  1186. #line 337 "parse.y"
  1187. { yyvsp[-1].command->flags |= CMD_WANT_SUBSHELL; yyval.command = yyvsp[-1].command; ;
  1188.     break;}
  1189. case 58:
  1190. #line 340 "parse.y"
  1191. { yyval.command = yyvsp[0].command; ;
  1192.     break;}
  1193. case 59:
  1194. #line 343 "parse.y"
  1195. { yyval.command = make_function_def (yyvsp[-4].word, yyvsp[0].command); ;
  1196.     break;}
  1197. case 60:
  1198. #line 346 "parse.y"
  1199. { yyval.command = make_function_def (yyvsp[-4].word, yyvsp[0].command); ;
  1200.     break;}
  1201. case 61:
  1202. #line 349 "parse.y"
  1203. { yyval.command = make_function_def (yyvsp[-2].word, yyvsp[0].command); ;
  1204.     break;}
  1205. case 62:
  1206. #line 353 "parse.y"
  1207. { yyval.command = make_if_command (yyvsp[-3].command, yyvsp[-1].command, (COMMAND *)NULL); ;
  1208.     break;}
  1209. case 63:
  1210. #line 355 "parse.y"
  1211. { yyval.command = make_if_command (yyvsp[-5].command, yyvsp[-3].command, yyvsp[-1].command); ;
  1212.     break;}
  1213. case 64:
  1214. #line 357 "parse.y"
  1215. { yyval.command = make_if_command (yyvsp[-4].command, yyvsp[-2].command, yyvsp[-1].command); ;
  1216.     break;}
  1217. case 65:
  1218. #line 362 "parse.y"
  1219. { yyval.command = make_group_command (yyvsp[-1].command); ;
  1220.     break;}
  1221. case 66:
  1222. #line 366 "parse.y"
  1223. { yyval.command = make_if_command (yyvsp[-2].command, yyvsp[0].command, (COMMAND *)NULL); ;
  1224.     break;}
  1225. case 67:
  1226. #line 368 "parse.y"
  1227. { yyval.command = make_if_command (yyvsp[-4].command, yyvsp[-2].command, yyvsp[0].command); ;
  1228.     break;}
  1229. case 68:
  1230. #line 370 "parse.y"
  1231. { yyval.command = make_if_command (yyvsp[-3].command, yyvsp[-1].command, yyvsp[0].command); ;
  1232.     break;}
  1233. case 70:
  1234. #line 375 "parse.y"
  1235. { yyvsp[0].pattern->next = yyvsp[-1].pattern; yyval.pattern = yyvsp[0].pattern; ;
  1236.     break;}
  1237. case 71:
  1238. #line 379 "parse.y"
  1239. { yyval.pattern = make_pattern_list (yyvsp[-2].word_list, yyvsp[0].command); ;
  1240.     break;}
  1241. case 72:
  1242. #line 381 "parse.y"
  1243. { yyval.pattern = make_pattern_list (yyvsp[-2].word_list, (COMMAND *)NULL); ;
  1244.     break;}
  1245. case 73:
  1246. #line 383 "parse.y"
  1247. { yyval.pattern = make_pattern_list (yyvsp[-2].word_list, yyvsp[0].command); ;
  1248.     break;}
  1249. case 74:
  1250. #line 385 "parse.y"
  1251. { yyval.pattern = make_pattern_list (yyvsp[-2].word_list, (COMMAND *)NULL); ;
  1252.     break;}
  1253. case 76:
  1254. #line 391 "parse.y"
  1255. { yyvsp[0].pattern->next = yyvsp[-1].pattern; yyval.pattern = yyvsp[0].pattern; ;
  1256.     break;}
  1257. case 77:
  1258. #line 395 "parse.y"
  1259. { yyval.pattern = make_pattern_list (yyvsp[-3].word_list, yyvsp[-1].command); ;
  1260.     break;}
  1261. case 78:
  1262. #line 397 "parse.y"
  1263. { yyval.pattern = make_pattern_list (yyvsp[-3].word_list, (COMMAND *)NULL); ;
  1264.     break;}
  1265. case 79:
  1266. #line 399 "parse.y"
  1267. { yyval.pattern = make_pattern_list (yyvsp[-3].word_list, yyvsp[-1].command); ;
  1268.     break;}
  1269. case 80:
  1270. #line 401 "parse.y"
  1271. { yyval.pattern = make_pattern_list (yyvsp[-3].word_list, (COMMAND *)NULL); ;
  1272.     break;}
  1273. case 81:
  1274. #line 405 "parse.y"
  1275. { yyval.word_list = make_word_list (yyvsp[0].word, (WORD_LIST *)NULL); ;
  1276.     break;}
  1277. case 82:
  1278. #line 407 "parse.y"
  1279. { yyval.word_list = make_word_list (yyvsp[0].word, yyvsp[-2].word_list); ;
  1280.     break;}
  1281. case 83:
  1282. #line 416 "parse.y"
  1283. {
  1284.               yyval.command = yyvsp[0].command;
  1285.               if (need_here_doc)
  1286.                 make_here_document (redirection_needing_here_doc);
  1287.               need_here_doc = 0;
  1288.              ;
  1289.     break;}
  1290. case 86:
  1291. #line 427 "parse.y"
  1292. { yyval.command = command_connect (yyvsp[-2].command, 0, '&'); ;
  1293.     break;}
  1294. case 88:
  1295. #line 433 "parse.y"
  1296. { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, AND_AND); ;
  1297.     break;}
  1298. case 89:
  1299. #line 435 "parse.y"
  1300. { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, OR_OR); ;
  1301.     break;}
  1302. case 90:
  1303. #line 437 "parse.y"
  1304. { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, '&'); ;
  1305.     break;}
  1306. case 91:
  1307. #line 439 "parse.y"
  1308. { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, ';'); ;
  1309.     break;}
  1310. case 92:
  1311. #line 441 "parse.y"
  1312. { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, ';'); ;
  1313.     break;}
  1314. case 93:
  1315. #line 443 "parse.y"
  1316. { yyval.command = yyvsp[0].command; ;
  1317.     break;}
  1318. case 94:
  1319. #line 445 "parse.y"
  1320. {
  1321.               yyvsp[0].command->flags |= CMD_INVERT_RETURN;
  1322.               yyval.command = yyvsp[0].command;
  1323.             ;
  1324.     break;}
  1325. case 100:
  1326. #line 467 "parse.y"
  1327. {
  1328.               yyval.command = yyvsp[0].command;
  1329.               if (need_here_doc)
  1330.                 make_here_document (redirection_needing_here_doc);
  1331.               need_here_doc = 0;
  1332.             ;
  1333.     break;}
  1334. case 101:
  1335. #line 474 "parse.y"
  1336. {
  1337.               yyval.command = command_connect (yyvsp[-1].command, (COMMAND *)NULL, '&');
  1338.               if (need_here_doc)
  1339.                 make_here_document (redirection_needing_here_doc);
  1340.               need_here_doc = 0;
  1341.             ;
  1342.     break;}
  1343. case 102:
  1344. #line 481 "parse.y"
  1345. {
  1346.               yyval.command = yyvsp[-1].command;
  1347.               if (need_here_doc)
  1348.                 make_here_document (redirection_needing_here_doc);
  1349.               need_here_doc = 0;
  1350.             ;
  1351.     break;}
  1352. case 103:
  1353. #line 490 "parse.y"
  1354. { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, AND_AND); ;
  1355.     break;}
  1356. case 104:
  1357. #line 492 "parse.y"
  1358. { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, OR_OR); ;
  1359.     break;}
  1360. case 105:
  1361. #line 494 "parse.y"
  1362. { yyval.command = command_connect (yyvsp[-2].command, yyvsp[0].command, '&'); ;
  1363.     break;}
  1364. case 106:
  1365. #line 496 "parse.y"
  1366. { yyval.command = command_connect (yyvsp[-2].command, yyvsp[0].command, ';'); ;
  1367.     break;}
  1368. case 107:
  1369. #line 498 "parse.y"
  1370. { yyval.command = yyvsp[0].command; ;
  1371.     break;}
  1372. case 108:
  1373. #line 500 "parse.y"
  1374. {
  1375.               yyvsp[0].command->flags |= CMD_INVERT_RETURN;
  1376.               yyval.command = yyvsp[0].command;
  1377.             ;
  1378.     break;}
  1379. case 109:
  1380. #line 508 "parse.y"
  1381. { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, '|'); ;
  1382.     break;}
  1383. case 110:
  1384. #line 510 "parse.y"
  1385. { yyval.command = yyvsp[0].command; ;
  1386.     break;}
  1387. }
  1388.    /* the action file gets copied in in place of this dollarsign */
  1389. #line 423 "/usr/gnu/lib/bison.simple"
  1390.  
  1391.   yyvsp -= yylen;
  1392.   yyssp -= yylen;
  1393. #ifdef YYLSP_NEEDED
  1394.   yylsp -= yylen;
  1395. #endif
  1396.  
  1397. #if YYDEBUG != 0
  1398.   if (yydebug)
  1399.     {
  1400.       short *ssp1 = yyss - 1;
  1401.       fprintf (stderr, "state stack now");
  1402.       while (ssp1 != yyssp)
  1403.     fprintf (stderr, " %d", *++ssp1);
  1404.       fprintf (stderr, "\n");
  1405.     }
  1406. #endif
  1407.  
  1408.   *++yyvsp = yyval;
  1409.  
  1410. #ifdef YYLSP_NEEDED
  1411.   yylsp++;
  1412.   if (yylen == 0)
  1413.     {
  1414.       yylsp->first_line = yylloc.first_line;
  1415.       yylsp->first_column = yylloc.first_column;
  1416.       yylsp->last_line = (yylsp-1)->last_line;
  1417.       yylsp->last_column = (yylsp-1)->last_column;
  1418.       yylsp->text = 0;
  1419.     }
  1420.   else
  1421.     {
  1422.       yylsp->last_line = (yylsp+yylen-1)->last_line;
  1423.       yylsp->last_column = (yylsp+yylen-1)->last_column;
  1424.     }
  1425. #endif
  1426.  
  1427.   /* Now "shift" the result of the reduction.
  1428.      Determine what state that goes to,
  1429.      based on the state we popped back to
  1430.      and the rule number reduced by.  */
  1431.  
  1432.   yyn = yyr1[yyn];
  1433.  
  1434.   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
  1435.   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
  1436.     yystate = yytable[yystate];
  1437.   else
  1438.     yystate = yydefgoto[yyn - YYNTBASE];
  1439.  
  1440.   goto yynewstate;
  1441.  
  1442. yyerrlab:   /* here on detecting error */
  1443.  
  1444.   if (! yyerrstatus)
  1445.     /* If not already recovering from an error, report this error.  */
  1446.     {
  1447.       ++yynerrs;
  1448.  
  1449. #ifdef YYERROR_VERBOSE
  1450.       yyn = yypact[yystate];
  1451.  
  1452.       if (yyn > YYFLAG && yyn < YYLAST)
  1453.     {
  1454.       int size = 0;
  1455.       char *msg;
  1456.       int x, count;
  1457.  
  1458.       count = 0;
  1459.       for (x = 0; x < (sizeof(yytname) / sizeof(char *)); x++)
  1460.         if (yycheck[x + yyn] == x)
  1461.           size += strlen(yytname[x]) + 15, count++;
  1462.       msg = (char *) xmalloc(size + 15);
  1463.       strcpy(msg, "parse error");
  1464.  
  1465.       if (count < 5)
  1466.         {
  1467.           count = 0;
  1468.           for (x = 0; x < (sizeof(yytname) / sizeof(char *)); x++)
  1469.         if (yycheck[x + yyn] == x)
  1470.           {
  1471.             strcat(msg, count == 0 ? ", expecting `" : " or `");
  1472.             strcat(msg, yytname[x]);
  1473.             strcat(msg, "'");
  1474.             count++;
  1475.           }
  1476.         }
  1477.       yyerror(msg);
  1478.       free(msg);
  1479.     }
  1480.       else
  1481. #endif /* YYERROR_VERBOSE */
  1482.     yyerror("parse error");
  1483.     }
  1484.  
  1485. yyerrlab1:   /* here on error raised explicitly by an action */
  1486.  
  1487.   if (yyerrstatus == 3)
  1488.     {
  1489.       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
  1490.  
  1491.       /* return failure if at end of input */
  1492.       if (yychar == YYEOF)
  1493.     YYABORT;
  1494.  
  1495. #if YYDEBUG != 0
  1496.       if (yydebug)
  1497.     fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
  1498. #endif
  1499.  
  1500.       yychar = YYEMPTY;
  1501.     }
  1502.  
  1503.   /* Else will try to reuse lookahead token
  1504.      after shifting the error token.  */
  1505.  
  1506.   yyerrstatus = 3;        /* Each real token shifted decrements this */
  1507.  
  1508.   goto yyerrhandle;
  1509.  
  1510. yyerrdefault:  /* current state does not do anything special for the error token. */
  1511.  
  1512. #if 0
  1513.   /* This is wrong; only states that explicitly want error tokens
  1514.      should shift them.  */
  1515.   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
  1516.   if (yyn) goto yydefault;
  1517. #endif
  1518.  
  1519. yyerrpop:   /* pop the current state because it cannot handle the error token */
  1520.  
  1521.   if (yyssp == yyss) YYABORT;
  1522.   yyvsp--;
  1523.   yystate = *--yyssp;
  1524. #ifdef YYLSP_NEEDED
  1525.   yylsp--;
  1526. #endif
  1527.  
  1528. #if YYDEBUG != 0
  1529.   if (yydebug)
  1530.     {
  1531.       short *ssp1 = yyss - 1;
  1532.       fprintf (stderr, "Error: state stack now");
  1533.       while (ssp1 != yyssp)
  1534.     fprintf (stderr, " %d", *++ssp1);
  1535.       fprintf (stderr, "\n");
  1536.     }
  1537. #endif
  1538.  
  1539. yyerrhandle:
  1540.  
  1541.   yyn = yypact[yystate];
  1542.   if (yyn == YYFLAG)
  1543.     goto yyerrdefault;
  1544.  
  1545.   yyn += YYTERROR;
  1546.   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
  1547.     goto yyerrdefault;
  1548.  
  1549.   yyn = yytable[yyn];
  1550.   if (yyn < 0)
  1551.     {
  1552.       if (yyn == YYFLAG)
  1553.     goto yyerrpop;
  1554.       yyn = -yyn;
  1555.       goto yyreduce;
  1556.     }
  1557.   else if (yyn == 0)
  1558.     goto yyerrpop;
  1559.  
  1560.   if (yyn == YYFINAL)
  1561.     YYACCEPT;
  1562.  
  1563. #if YYDEBUG != 0
  1564.   if (yydebug)
  1565.     fprintf(stderr, "Shifting error token, ");
  1566. #endif
  1567.  
  1568.   *++yyvsp = yylval;
  1569. #ifdef YYLSP_NEEDED
  1570.   *++yylsp = yylloc;
  1571. #endif
  1572.  
  1573.   yystate = yyn;
  1574.   goto yynewstate;
  1575. }
  1576. #line 512 "parse.y"
  1577.  
  1578.  
  1579. /* Initial size to allocate for tokens, and the
  1580.    amount to grow them by. */
  1581. #define TOKEN_DEFAULT_GROW_SIZE 512
  1582.  
  1583. /* The token currently being read. */
  1584. int current_token = 0;
  1585.  
  1586. /* The last read token, or NULL.  read_token () uses this for context
  1587.    checking. */
  1588. int last_read_token = 0;
  1589.  
  1590. /* The token read prior to last_read_token. */
  1591. int token_before_that = 0;
  1592.  
  1593. /* Global var is non-zero when end of file has been reached. */
  1594. int EOF_Reached = 0;
  1595.  
  1596. /* yy_getc () returns the next available character from input or EOF.
  1597.    yy_ungetc (c) makes `c' the next character to read.
  1598.    init_yy_io (get, unget, type, location) makes the function GET the
  1599.    installed function for getting the next character, makes UNGET the
  1600.    installed function for un-getting a character, set the type of stream
  1601.    (either string or file) from TYPE, and makes LOCATION point to where
  1602.    the input is coming from. */
  1603.  
  1604. /* Unconditionally returns end-of-file. */
  1605. return_EOF ()
  1606. {
  1607.   return (EOF);
  1608. }
  1609.  
  1610. /* Variable containing the current get and unget functions.
  1611.    See ./input.h for a clearer description. */
  1612. BASH_INPUT bash_input;
  1613.  
  1614. /* Set all of the fields in BASH_INPUT to NULL. */
  1615. void
  1616. initialize_bash_input ()
  1617. {
  1618.   bash_input.type = 0;
  1619.   bash_input.name = (char *)NULL;
  1620.   bash_input.location.file = (FILE *)NULL;
  1621.   bash_input.location.string = (char *)NULL;
  1622.   bash_input.getter = (Function *)NULL;
  1623.   bash_input.ungetter = (Function *)NULL;
  1624. }
  1625.  
  1626. /* Set the contents of the current bash input stream from
  1627.    GET, UNGET, TYPE, NAME, and LOCATION. */
  1628. init_yy_io (get, unget, type, name, location)
  1629.      Function *get, *unget;
  1630.      int type;
  1631.      char *name;
  1632.      INPUT_STREAM location;
  1633. {
  1634.   bash_input.type = type;
  1635.   if (bash_input.name)
  1636.     free (bash_input.name);
  1637.  
  1638.   if (name != (char *)NULL)
  1639.     bash_input.name = savestring (name);
  1640.   else
  1641.     bash_input.name = (char *)NULL;
  1642.  
  1643.   bash_input.location = location;
  1644.   bash_input.getter = get;
  1645.   bash_input.ungetter = unget;
  1646. }
  1647.  
  1648. /* Call this to get the next character of input. */
  1649. yy_getc ()
  1650. {
  1651.   return (*(bash_input.getter)) ();
  1652. }
  1653.  
  1654. /* Call this to unget C.  That is, to make C the next character
  1655.    to be read. */
  1656. yy_ungetc (c)
  1657. {
  1658.   return (*(bash_input.ungetter)) (c);
  1659. }
  1660.  
  1661. /* **************************************************************** */
  1662. /*                                    */
  1663. /*          Let input be read from readline ().            */
  1664. /*                                    */
  1665. /* **************************************************************** */
  1666.  
  1667. #if defined (READLINE)
  1668. char *current_readline_prompt = (char *)NULL;
  1669. char *current_readline_line = (char *)NULL;
  1670. int current_readline_line_index = 0;
  1671.  
  1672. static int readline_initialized_yet = 0;
  1673. int
  1674. yy_readline_get ()
  1675. {
  1676.   if (!current_readline_line)
  1677.     {
  1678.       extern sighandler sigint_sighandler ();
  1679.       extern int interrupt_immediately;
  1680.       extern char *readline ();
  1681.       SigHandler *old_sigint;
  1682. #if defined (JOB_CONTROL)
  1683.       extern pid_t shell_pgrp;
  1684.       extern int job_control;
  1685. #endif /* JOB_CONTROL */
  1686.  
  1687.       if (!readline_initialized_yet)
  1688.     {
  1689.       initialize_readline ();
  1690.       readline_initialized_yet = 1;
  1691.     }
  1692.  
  1693. #if defined (JOB_CONTROL)
  1694.       if (job_control)
  1695.     give_terminal_to (shell_pgrp);
  1696. #endif /* JOB_CONTROL */
  1697.  
  1698.       old_sigint = (SigHandler *)signal (SIGINT, sigint_sighandler);
  1699.       interrupt_immediately++;
  1700.  
  1701.       if (!current_readline_prompt)
  1702.     current_readline_line = readline ("");
  1703.       else
  1704.     current_readline_line = readline (current_readline_prompt);
  1705.  
  1706.       interrupt_immediately--;
  1707.       signal (SIGINT, old_sigint);
  1708.  
  1709.       /* Reset the prompt to whatever is in the decoded value of
  1710.      prompt_string_pointer. */
  1711.       reset_readline_prompt ();
  1712.  
  1713.       current_readline_line_index = 0;
  1714.  
  1715.       if (!current_readline_line)
  1716.     {
  1717.       current_readline_line_index = 0;
  1718.       return (EOF);
  1719.     }
  1720.  
  1721.       current_readline_line =
  1722.     (char *)xrealloc (current_readline_line,
  1723.               2 + strlen (current_readline_line));
  1724.       strcat (current_readline_line, "\n");
  1725.     }
  1726.  
  1727.   if (!current_readline_line[current_readline_line_index])
  1728.     {
  1729.       free (current_readline_line);
  1730.       current_readline_line = (char *)NULL;
  1731.       return (yy_readline_get ());
  1732.     }
  1733.   else
  1734.     {
  1735.       int c = current_readline_line[current_readline_line_index++];
  1736.       return (c);
  1737.     }
  1738. }
  1739.  
  1740. int
  1741. yy_readline_unget (c)
  1742. {
  1743.   if (current_readline_line_index && current_readline_line)
  1744.     current_readline_line[--current_readline_line_index] = c;
  1745.   return (c);
  1746. }
  1747.   
  1748. with_input_from_stdin ()
  1749. {
  1750.   INPUT_STREAM location;
  1751.  
  1752.   location.string = current_readline_line;
  1753.   init_yy_io (yy_readline_get, yy_readline_unget,
  1754.           st_string, "readline stdin", location);
  1755. }
  1756.  
  1757. #else  /* !READLINE */
  1758.  
  1759. with_input_from_stdin ()
  1760. {
  1761.   with_input_from_stream (stdin, "stdin");
  1762. }
  1763. #endif    /* !READLINE */
  1764.  
  1765. /* **************************************************************** */
  1766. /*                                    */
  1767. /*   Let input come from STRING.  STRING is zero terminated.        */
  1768. /*                                    */
  1769. /* **************************************************************** */
  1770.  
  1771. int
  1772. yy_string_get ()
  1773. {
  1774.   register char *string;
  1775.   register int c;
  1776.  
  1777.   string = bash_input.location.string;
  1778.   c = EOF;
  1779.  
  1780.   /* If the string doesn't exist, or is empty, EOF found. */
  1781.   if (string && *string)
  1782.     {
  1783.       c = *string++;
  1784.       bash_input.location.string = string;
  1785.     }
  1786.   return (c);
  1787. }
  1788.  
  1789. int
  1790. yy_string_unget (c)
  1791.      int c;
  1792. {
  1793.   *(--bash_input.location.string) = c;
  1794.   return (c);
  1795. }
  1796.  
  1797. void
  1798. with_input_from_string (string, name)
  1799.      char *string;
  1800.      char *name;
  1801. {
  1802.   INPUT_STREAM location;
  1803.  
  1804.   location.string = string;
  1805.  
  1806.   init_yy_io (yy_string_get, yy_string_unget, st_string, name, location);
  1807. }
  1808.  
  1809. /* **************************************************************** */
  1810. /*                                    */
  1811. /*             Let input come from STREAM.            */
  1812. /*                                    */
  1813. /* **************************************************************** */
  1814.  
  1815. int
  1816. yy_stream_get ()
  1817. {
  1818.   if (bash_input.location.file)
  1819. #if defined (USG) || (defined (_POSIX_VERSION) && defined (Ultrix))
  1820.     return (sysv_getc (bash_input.location.file));
  1821. #else
  1822.     return (getc (bash_input.location.file));
  1823. #endif    /* !USG && !(_POSIX_VERSION && Ultrix) */
  1824.   else
  1825.     return (EOF);
  1826. }
  1827.  
  1828. int
  1829. yy_stream_unget (c)
  1830.      int c;
  1831. {
  1832.   return (ungetc (c, bash_input.location.file));
  1833. }
  1834.  
  1835. with_input_from_stream (stream, name)
  1836.      FILE *stream;
  1837.      char *name;
  1838. {
  1839.   INPUT_STREAM location;
  1840.  
  1841.   location.file = stream;
  1842.   init_yy_io (yy_stream_get, yy_stream_unget, st_stream, name, location);
  1843. }
  1844.  
  1845. typedef struct stream_saver {
  1846.   struct stream_saver *next;
  1847.   BASH_INPUT bash_input;
  1848.   int line;
  1849. } STREAM_SAVER;
  1850.  
  1851. /* The globally known line number. */
  1852. int line_number = 0;
  1853.  
  1854. STREAM_SAVER *stream_list = (STREAM_SAVER *)NULL;
  1855.  
  1856. push_stream ()
  1857. {
  1858.   STREAM_SAVER *saver = (STREAM_SAVER *)xmalloc (sizeof (STREAM_SAVER));
  1859.  
  1860.   bcopy (&bash_input, &(saver->bash_input), sizeof (BASH_INPUT));
  1861.   saver->line = line_number;
  1862.   bash_input.name = (char *)NULL;
  1863.   saver->next = stream_list;
  1864.   stream_list = saver;
  1865.   EOF_Reached = line_number = 0;
  1866. }
  1867.  
  1868. pop_stream ()
  1869. {
  1870.   if (!stream_list)
  1871.     {
  1872.       EOF_Reached = 1;
  1873.     }
  1874.   else
  1875.     {
  1876.       STREAM_SAVER *saver = stream_list;
  1877.  
  1878.       EOF_Reached = 0;
  1879.       stream_list = stream_list->next;
  1880.  
  1881.       init_yy_io (saver->bash_input.getter,
  1882.           saver->bash_input.ungetter,
  1883.           saver->bash_input.type,
  1884.           saver->bash_input.name,
  1885.           saver->bash_input.location);
  1886.  
  1887.       line_number = saver->line;
  1888.  
  1889.       if (saver->bash_input.name)
  1890.     free (saver->bash_input.name);
  1891.  
  1892.       free (saver);
  1893.     }
  1894. }
  1895.  
  1896. /*
  1897.  * This is used to inhibit alias expansion and reserved word recognition
  1898.  * inside case statement pattern lists.  A `case statement pattern list'
  1899.  * is:
  1900.  *    everything between the `in' in a `case word in' and the next ')'
  1901.  *    or `esac'
  1902.  *    everything between a `;;' and the next `)' or `esac'
  1903.  */
  1904. static int in_case_pattern_list = 0;
  1905.  
  1906. #if defined (ALIAS)
  1907. /*
  1908.  * Pseudo-global variables used in implementing token-wise alias expansion.
  1909.  */
  1910.  
  1911. static int expand_next_token = 0;
  1912. static char *current_token_being_expanded = (char *)NULL;
  1913. static char *pending_token_being_expanded = (char *)NULL;
  1914.  
  1915. /*
  1916.  * Pushing and popping strings.  This works together with shell_getc to 
  1917.  * implement alias expansion on a per-token basis.
  1918.  */
  1919.  
  1920. typedef struct string_saver {
  1921.   struct string_saver *next;
  1922.   int expand_alias;  /* Value to set expand_alias to when string is popped. */
  1923.   char *saved_line;
  1924.   int saved_line_size, saved_line_index, saved_line_terminator;
  1925.   char *saved_token_being_expanded;
  1926. } STRING_SAVER;
  1927.  
  1928. STRING_SAVER *pushed_string_list = (STRING_SAVER *)NULL;
  1929.  
  1930. static void save_expansion ();
  1931.  
  1932. /*
  1933.  * Push the current shell_input_line onto a stack of such lines and make S
  1934.  * the current input.  Used when expanding aliases.  EXPAND is used to set
  1935.  * the value of expand_next_token when the string is popped, so that the
  1936.  * word after the alias in the original line is handled correctly when the
  1937.  * alias expands to multiple words.  TOKEN is the token that was expanded
  1938.  * into S; it is saved and used to prevent infinite recursive expansion.
  1939.  */
  1940. static void
  1941. push_string (s, expand, token)
  1942.      char *s;
  1943.      int expand;
  1944.      char *token;
  1945. {
  1946.   extern char *shell_input_line;
  1947.   extern int shell_input_line_size, shell_input_line_index,
  1948.          shell_input_line_terminator;
  1949.   STRING_SAVER *temp = (STRING_SAVER *) xmalloc (sizeof (STRING_SAVER));
  1950.  
  1951.   temp->expand_alias = expand;
  1952.   temp->saved_line = shell_input_line;
  1953.   temp->saved_line_size = shell_input_line_size;
  1954.   temp->saved_line_index = shell_input_line_index;
  1955.   temp->saved_line_terminator = shell_input_line_terminator;
  1956.   temp->saved_token_being_expanded = current_token_being_expanded;
  1957.   temp->next = pushed_string_list;
  1958.   pushed_string_list = temp;
  1959.  
  1960.   save_expansion (token);
  1961.  
  1962.   current_token_being_expanded = token;
  1963.   shell_input_line = s;
  1964.   shell_input_line_size = strlen (s);
  1965.   shell_input_line_index = 0;
  1966.   shell_input_line_terminator = '\0';
  1967.   expand_next_token = 0;
  1968. }
  1969.  
  1970. /*
  1971.  * Make the top of the pushed_string stack be the current shell input.
  1972.  * Only called when there is something on the stack.  Called from shell_getc
  1973.  * when it thinks it has consumed the string generated by an alias expansion
  1974.  * and needs to return to the original input line.
  1975.  */
  1976. static void
  1977. pop_string ()
  1978. {
  1979.   extern char *shell_input_line;
  1980.   extern int shell_input_line_size, shell_input_line_index,
  1981.          shell_input_line_terminator;
  1982.   STRING_SAVER *t;
  1983.  
  1984.   if (shell_input_line)
  1985.     free (shell_input_line);
  1986.   shell_input_line = pushed_string_list->saved_line;
  1987.   shell_input_line_index = pushed_string_list->saved_line_index;
  1988.   shell_input_line_size = pushed_string_list->saved_line_size;
  1989.   shell_input_line_terminator = pushed_string_list->saved_line_terminator;
  1990.   expand_next_token = pushed_string_list->expand_alias;
  1991.   pending_token_being_expanded = pushed_string_list->saved_token_being_expanded;
  1992.   t = pushed_string_list;
  1993.   pushed_string_list = pushed_string_list->next;
  1994.   free((char *)t);
  1995. }
  1996.  
  1997. static void
  1998. free_string_list ()
  1999. {
  2000.   register STRING_SAVER *t = pushed_string_list, *t1;
  2001.  
  2002.   while (t)
  2003.     {
  2004.       t1 = t->next;
  2005.       if (t->saved_line)
  2006.     free (t->saved_line);
  2007.       if (t->saved_token_being_expanded)
  2008.     free (t->saved_token_being_expanded);
  2009.       free ((char *)t);
  2010.       t = t1;
  2011.     }
  2012.   pushed_string_list = (STRING_SAVER *)NULL;
  2013. }
  2014.  
  2015. /* This is a stack to save the values of all tokens for which alias
  2016.    expansion has been performed during the current call to read_token ().
  2017.    It is used to prevent alias expansion loops:
  2018.  
  2019.       alias foo=bar
  2020.       alias bar=baz
  2021.       alias baz=foo
  2022.  
  2023.    Ideally this would be taken care of by push and pop string, but because
  2024.    of when strings are popped the stack will not contain the correct
  2025.    strings to test against.  (The popping is done in shell_getc, so that when
  2026.    the current string is exhausted, shell_getc can simply pop that string off
  2027.    the stack, restore the previous string, and continue with the character
  2028.    following the token whose expansion was originally pushed on the stack.)
  2029.  
  2030.    What we really want is a record of all tokens that have been expanded for
  2031.    aliases during the `current' call to read_token().  This does that, at the
  2032.    cost of being somewhat special-purpose (OK, OK vile and unclean).  Brian,
  2033.    you had better rewrite this whole piece of garbage before the next version
  2034.    is released.
  2035. */
  2036.  
  2037. typedef struct _exp_saver {
  2038.       struct _exp_saver *next;
  2039.       char *saved_token;
  2040. } EXPANSION_SAVER;
  2041.  
  2042. EXPANSION_SAVER *expanded_token_stack = (EXPANSION_SAVER *)NULL;
  2043.  
  2044. static void
  2045. save_expansion (s)
  2046.      char *s;
  2047. {
  2048.   EXPANSION_SAVER *t;
  2049.  
  2050.   t = (EXPANSION_SAVER *) xmalloc (sizeof (EXPANSION_SAVER));
  2051.   t->saved_token = savestring (s);
  2052.   t->next = expanded_token_stack;
  2053.   expanded_token_stack = t;
  2054. }
  2055.  
  2056. /*
  2057.  * Return 1 if TOKEN has already been expanded in the current `stack' of
  2058.  * expansions.  If it has been expanded already, it will appear as the value
  2059.  * of saved_token for some entry in the stack of expansions created for the
  2060.  * current token being expanded.
  2061.  */
  2062. static int
  2063. token_has_been_expanded (token)
  2064.      char *token;
  2065. {
  2066.   register EXPANSION_SAVER *t = expanded_token_stack;
  2067.  
  2068.   while (t)
  2069.     {
  2070.       if (STREQ (token, t->saved_token))
  2071.     return (1);
  2072.       t = t->next;
  2073.     }
  2074.   return (0);
  2075. }
  2076.  
  2077. static void
  2078. free_expansion_stack ()
  2079. {
  2080.   register EXPANSION_SAVER *t = expanded_token_stack, *t1;
  2081.  
  2082.   while (t)
  2083.     {
  2084.       t1 = t->next;
  2085.       free (t->saved_token);
  2086.       free (t);
  2087.       t = t1;
  2088.     }
  2089.   expanded_token_stack = (EXPANSION_SAVER *)NULL;
  2090. }
  2091.  
  2092. #endif /* ALIAS */
  2093.  
  2094. /* Return a line of text, taken from wherever yylex () reads input.
  2095.    If there is no more input, then we return NULL. */
  2096. char *
  2097. read_a_line ()
  2098. {
  2099.   char *line_buffer = (char *)NULL;
  2100.   int indx = 0, buffer_size = 0;
  2101.   int c;
  2102.  
  2103.   while (1)
  2104.     {
  2105.       c = yy_getc ();
  2106.  
  2107.       if (c == 0)
  2108.     continue;
  2109.  
  2110.       /* If there is no more input, then we return NULL. */
  2111.       if (c == EOF)
  2112.     {
  2113.       c = '\n';
  2114.       if (!line_buffer)
  2115.         return ((char *)NULL);
  2116.     }
  2117.  
  2118.       /* `+2' in case the final (200'th) character in the buffer is a newline;
  2119.      otherwise the code below that NULL-terminates it will write over the
  2120.      201st slot and kill the range checking in free(). */
  2121.       if (indx + 2 > buffer_size)
  2122.     if (!buffer_size)
  2123.       line_buffer = (char *)xmalloc (buffer_size = 200);
  2124.     else
  2125.       line_buffer = (char *)xrealloc (line_buffer, buffer_size += 200);
  2126.  
  2127.       line_buffer[indx++] = c;
  2128.       if (c == '\n')
  2129.     {
  2130.       line_buffer[indx] = '\0';
  2131.       return (line_buffer);
  2132.     }
  2133.     }
  2134. }
  2135.  
  2136. /* Return a line as in read_a_line (), but insure that the prompt is
  2137.    the secondary prompt. */
  2138. char *
  2139. read_secondary_line ()
  2140. {
  2141.   prompt_string_pointer = &ps2_prompt;
  2142.   prompt_again ();
  2143.   return (read_a_line ());
  2144. }
  2145.  
  2146.  
  2147. /* **************************************************************** */
  2148. /*                                    */
  2149. /*                YYLEX ()                */
  2150. /*                                    */
  2151. /* **************************************************************** */
  2152.  
  2153. /* Reserved words.  These are only recognized as the first word of a
  2154.    command.  TOKEN_WORD_ALIST. */
  2155. STRING_INT_ALIST word_token_alist[] = {
  2156.   { "if", IF },
  2157.   { "then", THEN },
  2158.   { "else", ELSE },
  2159.   { "elif", ELIF },
  2160.   { "fi", FI },
  2161.   { "case", CASE },
  2162.   { "esac", ESAC },
  2163.   { "for", FOR },
  2164.   { "while", WHILE },
  2165.   { "until", UNTIL },
  2166.   { "do", DO },
  2167.   { "done", DONE },
  2168.   { "in", IN },
  2169.   { "function", FUNCTION },
  2170.   { "{", '{' },
  2171.   { "}", '}' },
  2172.   { "!", BANG },
  2173.   { (char *)NULL,  0}
  2174. };
  2175.  
  2176. /* Where shell input comes from.  History expansion is performed on each
  2177.    line when the shell is interactive. */
  2178. char *shell_input_line = (char *)NULL;
  2179. int shell_input_line_index = 0;
  2180. int shell_input_line_size = 0;    /* Amount allocated for shell_input_line. */
  2181. int shell_input_line_len = 0;    /* strlen (shell_input_line) */
  2182.  
  2183. /* Either zero, or EOF. */
  2184. int shell_input_line_terminator = 0;
  2185.  
  2186. /* Return the next shell input character.  This always reads characters
  2187.    from shell_input_line; when that line is exhausted, it is time to
  2188.    read the next line. */
  2189. int
  2190. shell_getc (remove_quoted_newline)
  2191.      int remove_quoted_newline;
  2192. {
  2193.   int c;
  2194.  
  2195.   QUIT;
  2196.  
  2197. #if defined (ALIAS)
  2198.   /* If shell_input_line[shell_input_line_index] == 0, but there is
  2199.      something on the pushed list of strings, then we don't want to go
  2200.      off and get another line.  We let the code down below handle it. */
  2201.  
  2202.   if (!shell_input_line || ((!shell_input_line[shell_input_line_index]) &&
  2203.                 (pushed_string_list == (STRING_SAVER *)NULL)))
  2204. #else /* !ALIAS */
  2205.   if (!shell_input_line || !shell_input_line[shell_input_line_index])
  2206. #endif /* !ALIAS */
  2207.     {
  2208.       register int i, l;
  2209.       char *pre_process_line (), *expansions;
  2210.  
  2211.       restart_read_next_line:
  2212.  
  2213.       line_number++;
  2214.  
  2215.     restart_read:
  2216.  
  2217.       QUIT;    /* XXX experimental */
  2218.  
  2219.       i = 0;
  2220.       shell_input_line_terminator = 0;
  2221.  
  2222. #if defined (JOB_CONTROL)
  2223.       notify_and_cleanup ();
  2224. #endif
  2225.  
  2226.       clearerr (stdin);
  2227.       while (c = yy_getc ())
  2228.     {
  2229.       if (i + 2 > shell_input_line_size)
  2230.         shell_input_line = (char *)
  2231.           xrealloc (shell_input_line, shell_input_line_size += 256);
  2232.  
  2233.       if (c == EOF)
  2234.         {
  2235.           clearerr (stdin);
  2236.  
  2237.           if (!i)
  2238.         shell_input_line_terminator = EOF;
  2239.  
  2240.           shell_input_line[i] = '\0';
  2241.           break;
  2242.         }
  2243.  
  2244.       shell_input_line[i++] = c;
  2245.  
  2246.       if (c == '\n')
  2247.         {
  2248.           shell_input_line[--i] = '\0';
  2249.           current_command_line_count++;
  2250.           break;
  2251.         }
  2252.     }
  2253.       shell_input_line_index = 0;
  2254.       shell_input_line_len = i;        /* == strlen (shell_input_line) */
  2255.  
  2256.       if (!shell_input_line || !shell_input_line[0])
  2257.     goto after_pre_process;
  2258.  
  2259.       if (interactive)
  2260.     {
  2261.       expansions = pre_process_line (shell_input_line, 1, 1);
  2262.  
  2263.       free (shell_input_line);
  2264.       shell_input_line = expansions;
  2265.       shell_input_line_len = shell_input_line ?
  2266.                  strlen (shell_input_line) :
  2267.                  0;
  2268.       /* We have to force the xrealloc below because we don't know the
  2269.          true allocated size of shell_input_line anymore. */
  2270.       shell_input_line_size = shell_input_line_len;
  2271.     }
  2272.  
  2273.   after_pre_process:
  2274.       if (shell_input_line)
  2275.     {
  2276.       if (echo_input_at_read)
  2277.         fprintf (stderr, "%s\n", shell_input_line);
  2278.     }
  2279.       else
  2280.     {
  2281.       shell_input_line_size = 0;
  2282.       prompt_string_pointer = ¤t_prompt_string;
  2283.       prompt_again ();
  2284.       goto restart_read;
  2285.     }
  2286.  
  2287.       /* Add the newline to the end of this string, iff the string does
  2288.      not already end in an EOF character.  */
  2289.       if (shell_input_line_terminator != EOF)
  2290.     {
  2291.       l = shell_input_line_len;    /* was a call to strlen */
  2292.  
  2293.       if (l + 3 > shell_input_line_size)
  2294.         shell_input_line = (char *)xrealloc (shell_input_line,
  2295.                     1 + (shell_input_line_size += 2));
  2296.  
  2297.       strcpy (shell_input_line + l, "\n");
  2298.     }
  2299.     }
  2300.   
  2301.   c = shell_input_line[shell_input_line_index];
  2302.  
  2303.   if (c)
  2304.     shell_input_line_index++;
  2305.  
  2306.   if (c == '\\' && remove_quoted_newline &&
  2307.       shell_input_line[shell_input_line_index] == '\n')
  2308.     {
  2309.     prompt_again ();
  2310.     goto restart_read_next_line;
  2311.     }
  2312.  
  2313. #if defined (ALIAS)
  2314.   /*
  2315.    * If c is NULL, we have reached the end of the current input string.  If
  2316.    * pushed_string_list is non-empty, it's time to pop to the previous string
  2317.    * because we have fully consumed the result of the last alias expansion.
  2318.    * Do it transparently; just return the next character of the string popped
  2319.    * to.  We need to hang onto current_token_being_expanded until the token
  2320.    * currently being read has been recognized; we can't restore it in
  2321.    * pop_string () because the token currently being read would be
  2322.    * inappropriately compared with it.  We defer restoration until the next
  2323.    * call to read_token ().
  2324.    */
  2325.  
  2326.   if (!c && (pushed_string_list != (STRING_SAVER *)NULL))
  2327.     {
  2328.       pop_string ();
  2329.       c = shell_input_line[shell_input_line_index];
  2330.       if (c)
  2331.     shell_input_line_index++;
  2332.     }
  2333. #endif /* ALIAS */
  2334.  
  2335.   if (!c && shell_input_line_terminator == EOF)
  2336.     {
  2337.       if (shell_input_line_index != 0)
  2338.     return ('\n');
  2339.       else
  2340.     return (EOF);
  2341.     }
  2342.  
  2343.   return (c);
  2344. }
  2345.  
  2346. /* Put C back into the input for the shell. */
  2347. shell_ungetc (c)
  2348.      int c;
  2349. {
  2350.   if (shell_input_line && shell_input_line_index)
  2351.     shell_input_line[--shell_input_line_index] = c;
  2352. }
  2353.  
  2354. /* Discard input until CHARACTER is seen. */
  2355. discard_until (character)
  2356.      int character;
  2357. {
  2358.   int c;
  2359.  
  2360.   while ((c = shell_getc (0)) != EOF && c != character)
  2361.     ;
  2362.  
  2363.   if (c != EOF)
  2364.     shell_ungetc (c);
  2365. }
  2366.  
  2367. #if defined (HISTORY_REEDITING)
  2368. /* Tell readline () that we have some text for it to edit. */
  2369. re_edit (text)
  2370.      char *text;
  2371. {
  2372. #if defined (READLINE)
  2373.   if (strcmp (bash_input.name, "readline stdin") == 0)
  2374.     bash_re_edit (text);
  2375. #endif /* READLINE */
  2376. }
  2377. #endif /* HISTORY_REEDITING */
  2378.  
  2379. /* Non-zero means do no history expansion on this line, regardless
  2380.    of what history_expansion says. */
  2381. int history_expansion_inhibited = 0;
  2382.  
  2383. /* Do pre-processing on LINE.  If PRINT_CHANGES is non-zero, then
  2384.    print the results of expanding the line if there were any changes.
  2385.    If there is an error, return NULL, otherwise the expanded line is
  2386.    returned.  If ADDIT is non-zero the line is added to the history
  2387.    list after history expansion.  ADDIT is just a suggestion;
  2388.    REMEMBER_ON_HISTORY can veto, and does.
  2389.    Right now this does history expansion. */
  2390. char *
  2391. pre_process_line (line, print_changes, addit)
  2392.      char *line;
  2393.      int print_changes, addit;
  2394. {
  2395.   extern int remember_on_history;
  2396.   extern int history_expansion;
  2397.   extern int history_expand ();
  2398.   char *history_value;
  2399.   char *return_value;
  2400.   int expanded = 0;
  2401.  
  2402.   return_value = line;
  2403.  
  2404.   /* History expand the line.  If this results in no errors, then
  2405.      add that line to the history if ADDIT is non-zero. */
  2406.   if (!history_expansion_inhibited && history_expansion)
  2407.     {
  2408.       expanded = history_expand (line, &history_value);
  2409.  
  2410.       if (expanded)
  2411.     {
  2412.       if (print_changes)
  2413.         fprintf (stderr, "%s\n", history_value);
  2414.  
  2415.       /* If there was an error, return NULL. */
  2416.       if (expanded < 0)
  2417.         {
  2418.           free (history_value);
  2419.  
  2420. #if defined (HISTORY_REEDITING)
  2421.           /* New hack.  We can allow the user to edit the
  2422.          failed history expansion. */
  2423.           re_edit (line);
  2424. #endif /* HISTORY_REEDITING */
  2425.           return ((char *)NULL);
  2426.         }
  2427.     }
  2428.  
  2429.       /* Let other expansions know that return_value can be free'ed,
  2430.      and that a line has been added to the history list.  Note
  2431.      that we only add lines that have something in them. */
  2432.       expanded = 1;
  2433.       return_value = history_value;
  2434.     }
  2435.  
  2436.   if (addit && remember_on_history && *return_value)
  2437.     {
  2438.       extern int history_control;
  2439.  
  2440.       switch (history_control)
  2441.     {
  2442.       case 0:
  2443.         bash_add_history (return_value);
  2444.         break;
  2445.       case 1:
  2446.         if (*return_value != ' ')
  2447.           bash_add_history (return_value);
  2448.         break;
  2449.       case 2:
  2450.         {
  2451.           HIST_ENTRY *temp;
  2452.  
  2453.           using_history ();
  2454.           temp = previous_history ();
  2455.  
  2456.           if (!temp || (strcmp (temp->line, return_value) != 0))
  2457.         bash_add_history (return_value);
  2458.  
  2459.           using_history ();
  2460.         }
  2461.         break;
  2462.     }
  2463.     }
  2464.  
  2465.   if (!expanded)
  2466.     return_value = savestring (line);
  2467.  
  2468.   return (return_value);
  2469. }
  2470.  
  2471.  
  2472. /* Place to remember the token.  We try to keep the buffer
  2473.    at a reasonable size, but it can grow. */
  2474. char *token = (char *)NULL;
  2475.  
  2476. /* Current size of the token buffer. */
  2477. int token_buffer_size = 0;
  2478.  
  2479. /* Command to read_token () explaining what we want it to do. */
  2480. #define READ 0
  2481. #define RESET 1
  2482. #define prompt_is_ps1 \
  2483.       (!prompt_string_pointer || prompt_string_pointer == &ps1_prompt)
  2484.  
  2485. /* Function for yyparse to call.  yylex keeps track of
  2486.    the last two tokens read, and calls read_token.  */
  2487.  
  2488. yylex ()
  2489. {
  2490.   if (interactive && (!current_token || current_token == '\n'))
  2491.     {
  2492.       /* Before we print a prompt, we might have to check mailboxes.
  2493.      We do this only if it is time to do so. Notice that only here
  2494.      is the mail alarm reset; nothing takes place in check_mail ()
  2495.      except the checking of mail.  Please don't change this. */
  2496.       if (prompt_is_ps1 && time_to_check_mail ())
  2497.     {
  2498.       check_mail ();
  2499.       reset_mail_timer ();
  2500.     }
  2501.  
  2502.       /* Allow the execution of a random command just before the printing
  2503.      of each primary prompt.  If the shell variable PROMPT_COMMAND
  2504.      is set then the value of it is the command to execute. */
  2505.       if (prompt_is_ps1)
  2506.     {
  2507.       char *command_to_execute;
  2508.  
  2509.       command_to_execute = get_string_value ("PROMPT_COMMAND");
  2510.  
  2511.       if (command_to_execute)
  2512.         {
  2513.           extern Function *last_shell_builtin, *this_shell_builtin;
  2514.           extern int last_command_exit_value;
  2515.           Function *temp_last, *temp_this;
  2516.           int temp_exit_value, temp_eof_encountered;
  2517.  
  2518.           temp_last = last_shell_builtin;
  2519.           temp_this = this_shell_builtin;
  2520.           temp_exit_value = last_command_exit_value;
  2521.           temp_eof_encountered = eof_encountered;
  2522.  
  2523.           parse_and_execute
  2524.         (savestring (command_to_execute), "PROMPT_COMMAND");
  2525.  
  2526.           last_shell_builtin = temp_last;
  2527.           this_shell_builtin = temp_this;
  2528.           last_command_exit_value = temp_exit_value;
  2529.           eof_encountered = temp_eof_encountered;
  2530.         }
  2531.     }
  2532.       prompt_again ();
  2533.     }
  2534.  
  2535.   token_before_that = last_read_token;
  2536.   last_read_token = current_token;
  2537.   current_token = read_token (READ);
  2538.   return (current_token);
  2539. }
  2540.  
  2541. /* Called from shell.c when Control-C is typed at top level.  Or
  2542.    by the error rule at top level. */
  2543. reset_parser ()
  2544. {
  2545.   read_token (RESET);
  2546. }
  2547.   
  2548. /* When non-zero, we have read the required tokens
  2549.    which allow ESAC to be the next one read. */
  2550. static int allow_esac_as_next = 0;
  2551.  
  2552. /* When non-zero, accept single '{' as a token itself. */
  2553. static int allow_open_brace = 0;
  2554.  
  2555. /* DELIMITER is the value of the delimiter that is currently
  2556.    enclosing, or zero for none. */
  2557. static int delimiter = 0;
  2558. static int old_delimiter = 0;
  2559.  
  2560. /* When non-zero, an open-brace used to create a group is awaiting a close
  2561.    brace partner. */
  2562. static int open_brace_awaiting_satisfaction = 0;
  2563.  
  2564. /* If non-zero, it is the token that we want read_token to return regardless
  2565.    of what text is (or isn't) present to be read.  read_token resets this. */
  2566. int token_to_read = 0;
  2567.  
  2568. /* Read the next token.  Command can be READ (normal operation) or 
  2569.    RESET (to normalize state). */
  2570. read_token (command)
  2571.      int command;
  2572. {
  2573.   extern int interactive_shell;    /* Whether the current shell is interactive. */
  2574.   int character;        /* Current character. */
  2575.   int peek_char;        /* Temporary look-ahead character. */
  2576.   int result;            /* The thing to return. */
  2577.   WORD_DESC *the_word;        /* The value for YYLVAL when a WORD is read. */
  2578.  
  2579.   if (token_buffer_size < TOKEN_DEFAULT_GROW_SIZE)
  2580.     {
  2581.       if (token)
  2582.     free (token);
  2583.       token = (char *)xmalloc (token_buffer_size = TOKEN_DEFAULT_GROW_SIZE);
  2584.     }
  2585.  
  2586.   if (command == RESET)
  2587.     {
  2588.       delimiter = old_delimiter = 0;
  2589.       open_brace_awaiting_satisfaction = 0;
  2590.       in_case_pattern_list = 0;
  2591.  
  2592. #if defined (ALIAS)
  2593.       if (pushed_string_list)
  2594.     {
  2595.       free_string_list ();
  2596.       pushed_string_list = (STRING_SAVER *)NULL;
  2597.     }
  2598.  
  2599.       if (pending_token_being_expanded)
  2600.     {
  2601.       free (pending_token_being_expanded);
  2602.       pending_token_being_expanded = (char *)NULL;
  2603.     }
  2604.  
  2605.       if (current_token_being_expanded)
  2606.     {
  2607.       free (current_token_being_expanded);
  2608.       current_token_being_expanded = (char *)NULL;
  2609.     }
  2610.  
  2611.       if (expanded_token_stack)
  2612.     {
  2613.       free_expansion_stack ();
  2614.       expanded_token_stack = (EXPANSION_SAVER *)NULL;
  2615.     }
  2616.  
  2617.       expand_next_token = 0;
  2618. #endif /* ALIAS */
  2619.  
  2620.       if (shell_input_line)
  2621.     {
  2622.       free (shell_input_line);
  2623.       shell_input_line = (char *)NULL;
  2624.       shell_input_line_size = shell_input_line_index = 0;
  2625.     }
  2626.       last_read_token = '\n';
  2627.       token_to_read = '\n';
  2628.       return ('\n');
  2629.     }
  2630.  
  2631.   if (token_to_read)
  2632.     {
  2633.       int rt = token_to_read;
  2634.       token_to_read = 0;
  2635.       return (rt);
  2636.     }
  2637.  
  2638. #if defined (ALIAS)
  2639.   /*
  2640.    * Now we can replace current_token_being_expanded with 
  2641.    * pending_token_being_expanded, since the token that would be 
  2642.    * inappropriately compared has already been returned.
  2643.    *
  2644.    * To see why restoring current_token_being_expanded in pop_string ()
  2645.    * could be a problem, consider "alias foo=foo".  Then try to
  2646.    * expand `foo'.  The initial value of current_token_being_expanded is
  2647.    * NULL, so that is what is pushed onto pushed_string_list as the
  2648.    * value of saved_token_being_expanded.  "foo" then becomes shell_input_line.
  2649.    * read_token calls shell_getc for `f', `o', `o', and then shell_getc
  2650.    * hits the end of shell_input_line.  pushed_string_list is not empty
  2651.    * so it gets popped.  If we were to blindly restore
  2652.    * current_token_being_expanded at this point, `foo' would be compared
  2653.    * with a NULL string in the check for recursive expansion, and would
  2654.    * infinitely recurse.
  2655.    */
  2656.   if (pending_token_being_expanded)
  2657.     {
  2658.       if (current_token_being_expanded)
  2659.     free (current_token_being_expanded);
  2660.       current_token_being_expanded = pending_token_being_expanded;
  2661.       pending_token_being_expanded = (char *)NULL;
  2662.     }
  2663.  
  2664.   /* If we hit read_token () and there are no saved strings on the
  2665.      pushed_string_list, then we are no longer currently expanding a
  2666.      token.  This can't be done in pop_stream, because pop_stream
  2667.      may pop the stream before the current token has finished being
  2668.      completely expanded (consider what happens when we alias foo to foo,
  2669.      and then try to expand it). */
  2670.   if (!pushed_string_list && current_token_being_expanded)
  2671.     {
  2672.       free (current_token_being_expanded);
  2673.       current_token_being_expanded = (char *)NULL;
  2674.  
  2675.       if (expanded_token_stack)
  2676.     {
  2677.       free_expansion_stack ();
  2678.       expanded_token_stack = (EXPANSION_SAVER *)NULL;
  2679.     }
  2680.     }
  2681.  
  2682.   /* This is a place to jump back to once we have successfully expanded a
  2683.      token with an alias and pushed the string with push_string () */
  2684. re_read_token:
  2685.  
  2686. #endif /* ALIAS */
  2687.  
  2688.   /* Read a single word from input.  Start by skipping blanks. */
  2689.   while ((character = shell_getc (1)) != EOF && whitespace (character));
  2690.  
  2691.   if (character == EOF)
  2692.     return (yacc_EOF);
  2693.  
  2694.   if (character == '#' && !interactive)
  2695.     {
  2696.       /* A comment.  Discard until EOL or EOF, and then return a newline. */
  2697.       discard_until ('\n');
  2698.       shell_getc (0);
  2699.  
  2700.       /* If we're about to return an unquoted newline, we can go and collect
  2701.      the text of any pending here document. */
  2702.       if (need_here_doc)
  2703.     make_here_document (redirection_needing_here_doc);
  2704.       need_here_doc = 0;
  2705.  
  2706. #if defined (ALIAS)
  2707.       expand_next_token = 0;
  2708. #endif /* ALIAS */
  2709.  
  2710.       return ('\n');
  2711.     }
  2712.  
  2713.   if (character == '\n')
  2714.     {
  2715.       /* If we're about to return an unquoted newline, we can go and collect
  2716.      the text of any pending here document. */
  2717.       if (need_here_doc)
  2718.     make_here_document (redirection_needing_here_doc);
  2719.       need_here_doc = 0;
  2720.  
  2721. #if defined (ALIAS)
  2722.       expand_next_token = 0;
  2723. #endif /* ALIAS */
  2724.  
  2725.       return (character);
  2726.     }
  2727.  
  2728.   if (member (character, "()<>;&|"))
  2729.     {
  2730. #if defined (ALIAS)
  2731.       /* Turn off alias tokenization iff this character sequence would
  2732.      not leave us ready to read a command. */
  2733.       if (character == '<' || character == '>')
  2734.     expand_next_token = 0;
  2735. #endif /* ALIAS */
  2736.  
  2737.       /* Please note that the shell does not allow whitespace to
  2738.      appear in between tokens which are character pairs, such as
  2739.      "<<" or ">>".  I believe this is the correct behaviour. */
  2740.       if (character == (peek_char = shell_getc (1)))
  2741.     {
  2742.       switch (character)
  2743.         {
  2744.           /* If '<' then we could be at "<<" or at "<<-".  We have to
  2745.          look ahead one more character. */
  2746.         case '<':
  2747.           peek_char = shell_getc (1);
  2748.           if (peek_char == '-')
  2749.         return (LESS_LESS_MINUS);
  2750.           else
  2751.         {
  2752.           shell_ungetc (peek_char);
  2753.           return (LESS_LESS);
  2754.         }
  2755.  
  2756.         case '>':
  2757.           return (GREATER_GREATER);
  2758.  
  2759.         case ';':
  2760.           in_case_pattern_list = 1;
  2761. #if defined (ALIAS)
  2762.           expand_next_token = 0;
  2763. #endif /* ALIAS */
  2764.           return (SEMI_SEMI);
  2765.  
  2766.         case '&':
  2767.           return (AND_AND);
  2768.  
  2769.         case '|':
  2770.           return (OR_OR);
  2771.         }
  2772.     }
  2773.       else
  2774.     {
  2775.       if (peek_char == '&')
  2776.         {
  2777.           switch (character)
  2778.         {
  2779.         case '<': return (LESS_AND);
  2780.         case '>': return (GREATER_AND);
  2781.         }
  2782.         }
  2783.       if (character == '<' && peek_char == '>')
  2784.         return (LESS_GREATER);
  2785.       if (character == '>' && peek_char == '|')
  2786.         return (GREATER_BAR);
  2787.       if (peek_char == '>' && character == '&')
  2788.         return (AND_GREATER);
  2789.     }
  2790.       shell_ungetc (peek_char);
  2791.  
  2792.       /* If we look like we are reading the start of a function
  2793.      definition, then let the reader know about it so that
  2794.      we will do the right thing with `{'. */
  2795.       if (character == ')' &&
  2796.       last_read_token == '(' && token_before_that == WORD)
  2797.     {
  2798.       allow_open_brace = 1;
  2799. #if defined (ALIAS)
  2800.       expand_next_token = 0;
  2801. #endif /* ALIAS */
  2802.     }
  2803.  
  2804.       if (in_case_pattern_list && (character == ')'))
  2805.     in_case_pattern_list = 0;
  2806.  
  2807.       return (character);
  2808.     }
  2809.  
  2810.   /* Hack <&- (close stdin) case. */
  2811.   if (character == '-')
  2812.     {
  2813.       switch (last_read_token)
  2814.     {
  2815.     case LESS_AND:
  2816.     case GREATER_AND:
  2817.       return (character);
  2818.     }
  2819.     }
  2820.   
  2821.   /* Okay, if we got this far, we have to read a word.  Read one,
  2822.      and then check it against the known ones. */
  2823.   {
  2824.     /* Index into the token that we are building. */
  2825.     int token_index = 0;
  2826.  
  2827.     /* ALL_DIGITS becomes zero when we see a non-digit. */
  2828.     int all_digits = digit (character);
  2829.  
  2830.     /* DOLLAR_PRESENT becomes non-zero if we see a `$'. */
  2831.     int dollar_present = 0;
  2832.  
  2833.     /* QUOTED becomes non-zero if we see one of ("), ('), (`), or (\). */
  2834.     int quoted = 0;
  2835.  
  2836.     /* Non-zero means to ignore the value of the next character, and just
  2837.        to add it no matter what. */
  2838.     int pass_next_character = 0;
  2839.  
  2840.     /* Non-zero means parsing a dollar-paren construct.  It is the count of
  2841.        un-quoted closes we need to see. */
  2842.     int dollar_paren_level = 0;
  2843.  
  2844.     /* Non-zero means parsing a dollar-bracket construct ($[...]).  It is
  2845.        the count of un-quoted `]' characters we need to see. */
  2846.     int dollar_bracket_level = 0;
  2847.  
  2848.     /* Another level variable.  This one is for dollar_parens inside of
  2849.        double-quotes. */
  2850.     int delimited_paren_level = 0;
  2851.  
  2852.     for (;;)
  2853.       {
  2854.     if (character == EOF)
  2855.       goto got_token;
  2856.  
  2857.     if (pass_next_character)
  2858.       {
  2859.         pass_next_character = 0;
  2860.         goto got_character;
  2861.       }
  2862.  
  2863.       if (delimiter && character == '\\' && delimiter != '\'')
  2864.     {
  2865.       peek_char = shell_getc (0);
  2866.       if (peek_char != '\\')
  2867.         shell_ungetc (peek_char);
  2868.       else
  2869.         {
  2870.           token[token_index++] = character;
  2871.           goto got_character;
  2872.         }
  2873.     }
  2874.  
  2875.     /* Handle backslashes.  Quote lots of things when not inside of
  2876.        double-quotes, quote some things inside of double-quotes. */
  2877.        
  2878.     if (character == '\\' && delimiter != '\'')
  2879.       {
  2880.         peek_char = shell_getc (0);
  2881.  
  2882.         /* Backslash-newline is ignored in all cases excepting
  2883.            when quoted with single quotes. */
  2884.         if (peek_char == '\n')
  2885.           {
  2886.         character = '\n';
  2887.         goto next_character;
  2888.           }
  2889.         else
  2890.           {
  2891.         shell_ungetc (peek_char);
  2892.  
  2893.         /* If the next character is to be quoted, do it now. */
  2894.         if (!delimiter || delimiter == '`' ||
  2895.             ((delimiter == '"' ) &&
  2896.              (member (peek_char, slashify_in_quotes))))
  2897.           {
  2898.             pass_next_character++;
  2899.             quoted = 1;
  2900.             goto got_character;
  2901.           }
  2902.           }
  2903.       }
  2904.  
  2905.     /* This is a hack, in its present form.  If a backquote substitution
  2906.        appears within double quotes, everything within the backquotes
  2907.        should be read as part of a single word.  Jesus.  Now I see why
  2908.        Korn introduced the $() form. */
  2909.     if (delimiter && delimiter == '"' && character == '`')
  2910.       {
  2911.         old_delimiter = delimiter;
  2912.         delimiter = character;
  2913.         goto got_character;
  2914.       }
  2915.  
  2916.     if (delimiter)
  2917.       {
  2918.         if (character == delimiter)
  2919.           {
  2920.         if (delimited_paren_level)
  2921.           {
  2922. #if defined (NOTDEF)
  2923.             report_error ("Expected ')' before %c", character);
  2924.             return ('\n');
  2925. #else
  2926.             goto got_character;
  2927. #endif /* NOTDEF */
  2928.           }
  2929.  
  2930.         delimiter = 0;
  2931.  
  2932.         if (old_delimiter == '"' && character == '`')
  2933.           {
  2934.             delimiter = old_delimiter;
  2935.             old_delimiter = 0;
  2936.           }
  2937.  
  2938.         goto got_character;
  2939.           }
  2940.       }
  2941.  
  2942.     if (!delimiter || delimiter == '`' || delimiter == '"')
  2943.       {
  2944.         if (character == '$')
  2945.           {
  2946.         peek_char = shell_getc (1);
  2947.         shell_ungetc (peek_char);
  2948.         if (peek_char == '(')
  2949.           {
  2950.             if (!delimiter)
  2951.               dollar_paren_level++;
  2952.             else
  2953.               delimited_paren_level++;
  2954.  
  2955.             pass_next_character++;
  2956.             goto got_character;
  2957.           }
  2958.         else if (peek_char == '[')
  2959.           {
  2960.             if (!delimiter)
  2961.               dollar_bracket_level++;
  2962.  
  2963.             pass_next_character++;
  2964.             goto got_character;
  2965.           }
  2966.           }
  2967.  
  2968.         /* If we are parsing a $() or $[] construct, we need to balance
  2969.            parens and brackets inside the construct.  This whole function
  2970.            could use a rewrite. */
  2971.         if (character == '(')
  2972.           {
  2973.         if (delimiter && delimited_paren_level)
  2974.           delimited_paren_level++;
  2975.  
  2976.         if (!delimiter && dollar_paren_level)
  2977.           dollar_paren_level++;
  2978.           }
  2979.  
  2980.         if (character == '[')
  2981.           {
  2982.         if (!delimiter && dollar_bracket_level)
  2983.           dollar_bracket_level++;
  2984.           }
  2985.  
  2986.         /* This code needs to take into account whether we are inside a
  2987.            case statement pattern list, and whether this paren is supposed
  2988.            to terminate it (hey, it could happen).  It's not as simple
  2989.            as just using in_case_pattern_list, because we're not parsing
  2990.            anything while we're reading a $( ) construct.  Maybe we
  2991.            should move that whole mess into the yacc parser. */
  2992.         if (character == ')')
  2993.           {
  2994.         if (delimiter && delimited_paren_level)
  2995.           delimited_paren_level--;
  2996.  
  2997.         if (!delimiter && dollar_paren_level)
  2998.           {
  2999.             dollar_paren_level--;
  3000.             goto got_character;
  3001.           }
  3002.           }
  3003.  
  3004.         if (character == ']')
  3005.           {
  3006.         if (!delimiter && dollar_bracket_level)
  3007.           {
  3008.             dollar_bracket_level--;
  3009.             goto got_character;
  3010.           }
  3011.           }
  3012.       }
  3013.  
  3014.     if (!dollar_paren_level && !dollar_bracket_level && !delimiter &&
  3015.         member (character, " \t\n;&()|<>"))
  3016.       {
  3017.         shell_ungetc (character);
  3018.         goto got_token;
  3019.       }
  3020.     
  3021.     if (!delimiter)
  3022.       {
  3023.         if (character == '"' || character == '`' || character == '\'')
  3024.           {
  3025.         quoted = 1;
  3026.         delimiter = character;
  3027.         goto got_character;
  3028.           }
  3029.       }
  3030.  
  3031.     if (all_digits) all_digits = digit (character);
  3032.     if (character == '$') dollar_present = 1;
  3033.  
  3034.       got_character:
  3035.  
  3036.     token[token_index++] = character;
  3037.  
  3038.     if (token_index == (token_buffer_size - 1))
  3039.       token = (char *)xrealloc (token, (token_buffer_size
  3040.                         += TOKEN_DEFAULT_GROW_SIZE));
  3041.     {
  3042.       char *decode_prompt_string ();
  3043.  
  3044.     next_character:
  3045.       if (character == '\n' && interactive && bash_input.type != st_string)
  3046.         prompt_again ();
  3047.     }
  3048.     /* We want to remove quoted newlines (that is, a \<newline> pair)
  3049.        unless we are within single quotes or pass_next_character is
  3050.        set (the shell equivalent of literal-next). */
  3051.     character = shell_getc ((delimiter != '\'') && (!pass_next_character));
  3052.       }
  3053.  
  3054.   got_token:
  3055.  
  3056.     token[token_index] = '\0';
  3057.     
  3058.     if ((delimiter || dollar_paren_level || dollar_bracket_level) &&
  3059.     character == EOF)
  3060.       {
  3061.     if (dollar_paren_level && !delimiter)
  3062.       delimiter = ')';
  3063.     else if (dollar_bracket_level && !delimiter)
  3064.       delimiter = ']';
  3065.  
  3066.     report_error ("Unexpected EOF.  Looking for `%c'.", delimiter);
  3067.     return (-1);
  3068.       }
  3069.  
  3070.     if (all_digits)
  3071.       {
  3072.     /* Check to see what thing we should return.  If the last_read_token
  3073.        is a `<', or a `&', or the character which ended this token is
  3074.        a '>' or '<', then, and ONLY then, is this input token a NUMBER.
  3075.        Otherwise, it is just a word, and should be returned as such. */
  3076.  
  3077.     if ((character == '<' || character == '>') ||
  3078.         (last_read_token == LESS_AND ||
  3079.          last_read_token == GREATER_AND))
  3080.       {
  3081.         yylval.number = atoi (token); /* was sscanf (token, "%d", &(yylval.number)); */
  3082.         return (NUMBER);
  3083.       }
  3084.       }
  3085.  
  3086.     /* Handle special case.  IN is recognized if the last token
  3087.        was WORD and the token before that was FOR or CASE. */
  3088.     if ((last_read_token == WORD) &&
  3089.     ((token_before_that == FOR) || (token_before_that == CASE)) &&
  3090.     (STREQ (token, "in")))
  3091.       {
  3092.     if (token_before_that == CASE)
  3093.       {
  3094.         in_case_pattern_list = 1;
  3095.         allow_esac_as_next++;
  3096.       }
  3097.     return (IN);
  3098.       }
  3099.  
  3100.     /* Ditto for DO in the FOR case. */
  3101.     if ((last_read_token == WORD) && (token_before_that == FOR) &&
  3102.     (STREQ (token, "do")))
  3103.       return (DO);
  3104.  
  3105.     /* Ditto for ESAC in the CASE case. 
  3106.        Specifically, this handles "case word in esac", which is a legal
  3107.        construct, certainly because someone will pass an empty arg to the
  3108.        case construct, and we don't want it to barf.  Of course, we should
  3109.        insist that the case construct has at least one pattern in it, but
  3110.        the designers disagree. */
  3111.     if (allow_esac_as_next)
  3112.       {
  3113.     allow_esac_as_next--;
  3114.     if (STREQ (token, "esac"))
  3115.       {
  3116.         in_case_pattern_list = 0;
  3117.         return (ESAC);
  3118.       }
  3119.       }
  3120.  
  3121.     /* Ditto for `{' in the FUNCTION case. */
  3122.     if (allow_open_brace)
  3123.       {
  3124.     allow_open_brace = 0;
  3125.     if (STREQ (token, "{"))
  3126.       {
  3127.         open_brace_awaiting_satisfaction++;
  3128.         return ('{');
  3129.       }
  3130.       }
  3131.  
  3132. #if defined (ALIAS)
  3133.  
  3134. #define command_token_position(token) \
  3135.     ((token) != SEMI_SEMI && reserved_word_acceptable (token))
  3136.  
  3137.     /* OK, we have a token.  Let's try to alias expand it, if (and only if)
  3138.        it's eligible. 
  3139.  
  3140.        It is eligible for expansion if the shell is in interactive mode, and
  3141.        the token is unquoted and the last token read was a command
  3142.        separator (or expand_next_token is set), and we are currently
  3143.        processing an alias (pushed_string_list is non-empty) and this
  3144.        token is not the same as the current or any previously
  3145.        processed alias.
  3146.  
  3147.        Special cases that disqualify:
  3148.      In a pattern list in a case statement (in_case_pattern_list). */
  3149.     if (interactive_shell && !quoted && !in_case_pattern_list &&
  3150.     (command_token_position (last_read_token) || expand_next_token))
  3151.       {
  3152.     char *alias_expand_word (), *expanded;
  3153.     if (current_token_being_expanded &&
  3154.          ((STREQ (token, current_token_being_expanded)) ||
  3155.           (token_has_been_expanded (token))))
  3156.       goto no_expansion;
  3157.  
  3158.     expanded = alias_expand_word (token);
  3159.     if (expanded)
  3160.       {
  3161.         int len = strlen (expanded), expand_next;
  3162.         char *temp;
  3163.  
  3164.         /* Erase the current token. */
  3165.         token_index = 0;
  3166.  
  3167.         expand_next = (expanded[len - 1] == ' ') ||
  3168.               (expanded[len - 1] == '\t');
  3169.  
  3170.         temp = savestring (token);
  3171.         push_string (expanded, expand_next, temp);
  3172.         goto re_read_token;
  3173.       }
  3174.     else
  3175.       /* This is an eligible token that does not have an expansion. */
  3176. no_expansion:
  3177.       expand_next_token = 0;
  3178.       }
  3179.     else
  3180.       {
  3181.     expand_next_token = 0;
  3182.       }
  3183. #endif /* ALIAS */
  3184.  
  3185.     /* Check to see if it is a reserved word.  */
  3186.     if (!dollar_present && !quoted &&
  3187.     reserved_word_acceptable (last_read_token))
  3188.       {
  3189.     int i;
  3190.     for (i = 0; word_token_alist[i].word != (char *)NULL; i++)
  3191.       if (STREQ (token, word_token_alist[i].word))
  3192.         {
  3193.           if (in_case_pattern_list && (word_token_alist[i].token != ESAC))
  3194.         break;
  3195.  
  3196.           if (word_token_alist[i].token == ESAC)
  3197.         in_case_pattern_list = 0;
  3198.  
  3199.           if (word_token_alist[i].token == '{')
  3200.         open_brace_awaiting_satisfaction++;
  3201.  
  3202.           return (word_token_alist[i].token);
  3203.         }
  3204.       }
  3205.  
  3206.     /* What if we are attempting to satisfy an open-brace grouper? */
  3207.     if (open_brace_awaiting_satisfaction && strcmp (token, "}") == 0)
  3208.       {
  3209.     open_brace_awaiting_satisfaction--;
  3210.     return ('}');
  3211.       }
  3212.  
  3213.     the_word = (WORD_DESC *)xmalloc (sizeof (WORD_DESC));
  3214.     the_word->word = (char *)xmalloc (1 + strlen (token));
  3215.     strcpy (the_word->word, token);
  3216.     the_word->dollar_present = dollar_present;
  3217.     the_word->quoted = quoted;
  3218.     the_word->assignment = assignment (token);
  3219.  
  3220.     yylval.word = the_word;
  3221.     result = WORD;
  3222.     if (last_read_token == FUNCTION)
  3223.       allow_open_brace = 1;
  3224.   }
  3225.   return (result);
  3226. }
  3227.  
  3228. #if defined (NOTDEF)        /* Obsoleted function no longer used. */
  3229. /* Return 1 if this token is a legal shell `identifier'; that is, it consists
  3230.    solely of letters, digits, and underscores, and does not begin with a 
  3231.    digit. */
  3232. legal_identifier (name)
  3233.      char *name;
  3234. {
  3235.   register char *s;
  3236.  
  3237.   if (!name || !*name)
  3238.     return (0);
  3239.  
  3240.   if (digit (*name))
  3241.     return (0);
  3242.  
  3243.   for (s = name; s && *s; s++)
  3244.     {
  3245.       if (!isletter (*s) && !digit (*s) && (*s != '_'))
  3246.     return (0);
  3247.     }
  3248.   return (1);
  3249. }
  3250. #endif /* NOTDEF */
  3251.  
  3252. /* Return 1 if TOKEN is a token that after being read would allow
  3253.    a reserved word to be seen, else 0. */
  3254. static int
  3255. reserved_word_acceptable (token)
  3256.      int token;
  3257. {
  3258.   if (member (token, "\n;()|&{") ||
  3259.       token == AND_AND ||
  3260.       token == BANG ||
  3261.       token == DO ||
  3262.       token == ELIF ||
  3263.       token == ELSE ||
  3264.       token == IF ||
  3265.       token == OR_OR ||
  3266.       token == SEMI_SEMI ||
  3267.       token == THEN ||
  3268.       token == UNTIL ||
  3269.       token == WHILE ||
  3270.       token == 0)
  3271.     return (1);
  3272.   else
  3273.     return (0);
  3274. }
  3275.  
  3276. #if defined (READLINE)
  3277. /* Called after each time readline is called.  This insures that whatever
  3278.    the new prompt string is gets propagated to readline's local prompt
  3279.    variable. */
  3280. reset_readline_prompt ()
  3281. {
  3282.   if (prompt_string_pointer && *prompt_string_pointer)
  3283.     {
  3284.       char *temp_prompt, *decode_prompt_string ();
  3285.  
  3286.       temp_prompt = decode_prompt_string (*prompt_string_pointer);
  3287.  
  3288.       if (!temp_prompt)
  3289.     temp_prompt = savestring ("");
  3290.  
  3291.       if (current_readline_prompt)
  3292.     free (current_readline_prompt);
  3293.  
  3294.       current_readline_prompt = temp_prompt;
  3295.     }
  3296. }
  3297. #endif
  3298.  
  3299. /* A list of tokens which can be followed by newlines, but not by
  3300.    semi-colons.  When concatenating multiple lines of history, the
  3301.    newline separator for such tokens is replaced with a space. */
  3302. int no_semi_successors[] = {
  3303.   '\n', '{', '(', ')', ';',
  3304.   CASE, DO, ELSE, IF, IN, SEMI_SEMI, THEN, UNTIL, WHILE,
  3305.   0
  3306. };
  3307.  
  3308. /* Add a line to the history list.
  3309.    The variable COMMAND_ORIENTED_HISTORY controls the style of history
  3310.    remembering;  when non-zero, and LINE is not the first line of a
  3311.    complete parser construct, append LINE to the last history line instead
  3312.    of adding it as a new line. */
  3313. bash_add_history (line)
  3314.      char *line;
  3315. {
  3316.   extern int command_oriented_history;
  3317.   int add_it = 1;
  3318.  
  3319.   if (command_oriented_history && current_command_line_count > 1)
  3320.     {
  3321.       register int offset;
  3322.       register HIST_ENTRY *current, *old;
  3323.       char *chars_to_add, *new_line;
  3324.  
  3325.       /* If we are not within a delimited expression, try to be smart
  3326.      about which separators can be semi-colons and which must be
  3327.      newlines. */
  3328.       if (!delimiter)
  3329.     {
  3330.       register int i;
  3331.  
  3332.       chars_to_add = (char *)NULL;
  3333.  
  3334.       for (i = 0; no_semi_successors[i]; i++)
  3335.         {
  3336.           if (token_before_that == no_semi_successors[i])
  3337.         {
  3338.           chars_to_add = " ";
  3339.           break;
  3340.         }
  3341.         }
  3342.       if (!chars_to_add)
  3343.         chars_to_add = "; ";
  3344.     }
  3345.       else
  3346.     chars_to_add = "\n";
  3347.  
  3348.       using_history ();
  3349.  
  3350.       current = previous_history ();
  3351.  
  3352.       if (current)
  3353.     {
  3354.       offset = where_history ();
  3355.       new_line = (char *) xmalloc (1
  3356.                        + strlen (current->line)
  3357.                        + strlen (line)
  3358.                        + strlen (chars_to_add));
  3359.       sprintf (new_line, "%s%s%s", current->line, chars_to_add, line);
  3360.       old = replace_history_entry (offset, new_line, current->data);
  3361.       free (new_line);
  3362.  
  3363.       if (old)
  3364.         {
  3365.           /* Note that the old data is not freed, since it was simply
  3366.          copied to the new history entry. */
  3367.           if (old->line)
  3368.         free (old->line);
  3369.  
  3370.           free (old);
  3371.         }
  3372.       add_it = 0;
  3373.     }
  3374.     }
  3375.  
  3376.   if (add_it)
  3377.     {
  3378.       extern int history_lines_this_session;
  3379.  
  3380.       add_history (line);
  3381.       history_lines_this_session++;
  3382.     }
  3383.   using_history ();
  3384. }
  3385.  
  3386. /* Issue a prompt, or prepare to issue a prompt when the next character
  3387.    is read. */
  3388. prompt_again ()
  3389. {
  3390.   char *temp_prompt, *decode_prompt_string ();
  3391.  
  3392.   ps1_prompt = get_string_value ("PS1");
  3393.   ps2_prompt = get_string_value ("PS2");
  3394.  
  3395.   if (!prompt_string_pointer)
  3396.     prompt_string_pointer = &ps1_prompt;
  3397.  
  3398.   if (*prompt_string_pointer)
  3399.     temp_prompt = decode_prompt_string (*prompt_string_pointer);
  3400.   else
  3401.     temp_prompt = savestring ("");
  3402.  
  3403.   current_prompt_string = *prompt_string_pointer;
  3404.   prompt_string_pointer = &ps2_prompt;
  3405.  
  3406. #if defined (READLINE)
  3407.   if (!no_line_editing)
  3408.     {
  3409.       if (current_readline_prompt)
  3410.     free (current_readline_prompt);
  3411.       
  3412.       current_readline_prompt = temp_prompt;
  3413.     }
  3414.   else
  3415. #endif    /* READLINE */
  3416.     {
  3417.       if (interactive)
  3418.     {
  3419.       fprintf (stderr, "%s", temp_prompt);
  3420.       fflush (stderr);
  3421.     }
  3422.       free (temp_prompt);
  3423.     }
  3424. }
  3425.  
  3426. #include "maxpath.h"
  3427.  
  3428. /* Return a string which will be printed as a prompt.  The string
  3429.    may contain special characters which are decoded as follows:
  3430.    
  3431.     \t    the time
  3432.     \d    the date
  3433.     \n    CRLF
  3434.     \s    the name of the shell
  3435.     \w    the current working directory
  3436.     \W    the last element of PWD
  3437.     \u    your username
  3438.     \h    the hostname
  3439.     \#    the command number of this command
  3440.     \!    the history number of this command
  3441.     \$    a $ or a # if you are root
  3442.     \<octal> character code in octal
  3443.     \\    a backslash
  3444. */
  3445. #include <sys/param.h>
  3446. #include <time.h>
  3447.  
  3448. #define PROMPT_GROWTH 50
  3449. char *
  3450. decode_prompt_string (string)
  3451.      char *string;
  3452. {
  3453.   int result_size = PROMPT_GROWTH;
  3454.   int result_index = 0;
  3455.   char *result = (char *)xmalloc (PROMPT_GROWTH);
  3456.   int c;
  3457.   char *temp = (char *)NULL;
  3458.  
  3459.   result[0] = 0;
  3460.   while (c = *string++)
  3461.     {
  3462.       if (c == '\\')
  3463.     {
  3464.       c = *string;
  3465.  
  3466.       switch (c)
  3467.         {
  3468.         case '0':
  3469.         case '1':
  3470.         case '2':
  3471.         case '3':
  3472.         case '4':
  3473.         case '5':
  3474.         case '6':
  3475.         case '7':
  3476.           {
  3477.         char octal_string[4];
  3478.         int n;
  3479.  
  3480.         strncpy (octal_string, string, 3);
  3481.         octal_string[3] = '\0';
  3482.  
  3483.         n = read_octal (octal_string);
  3484.  
  3485.         temp = savestring ("\\");
  3486.         if (n != -1)
  3487.           {
  3488.             string += 3;
  3489.             temp[0] = n;
  3490.           }
  3491.  
  3492.         c = 0;
  3493.         goto add_string;
  3494.           }
  3495.       
  3496.         case 't':
  3497.         case 'd':
  3498.           /* Make the current time/date into a string. */
  3499.           {
  3500.         long the_time = time (0);
  3501.         char *ttemp = ctime (&the_time);
  3502.         temp = savestring (ttemp);
  3503.  
  3504.         if (c == 't')
  3505.           {
  3506.             strcpy (temp, temp + 11);
  3507.             temp[8] = '\0';
  3508.           }
  3509.         else
  3510.           temp[10] = '\0';
  3511.  
  3512.         goto add_string;
  3513.           }
  3514.  
  3515.         case 'n':
  3516.           if (!no_line_editing)
  3517.         temp = savestring ("\r\n");
  3518.           else
  3519.         temp = savestring ("\n");
  3520.           goto add_string;
  3521.  
  3522.         case 's':
  3523.           {
  3524.         extern char *shell_name;
  3525.         extern char *base_pathname ();
  3526.  
  3527.         temp = base_pathname (shell_name);
  3528.         temp = savestring (temp);
  3529.         goto add_string;
  3530.           }
  3531.     
  3532.         case 'w':
  3533.         case 'W':
  3534.           {
  3535.         /* Use the value of PWD because it is much more effecient. */
  3536. #define EFFICIENT
  3537. #ifdef EFFICIENT
  3538.         char *polite_directory_format (), t_string[MAXPATHLEN];
  3539.  
  3540.         temp = get_string_value ("PWD");
  3541.  
  3542.         if (!temp)
  3543.           getwd (t_string);
  3544.         else
  3545.           strcpy (t_string, temp);
  3546. #else
  3547.         getwd (t_string);
  3548. #endif    /* EFFICIENT */
  3549.  
  3550.         if (c == 'W')
  3551.           {
  3552.             char *dir = (char *)rindex (t_string, '/');
  3553.             if (dir && dir != t_string)
  3554.               strcpy (t_string, dir + 1);
  3555.             temp = savestring (t_string);
  3556.           }
  3557.         else
  3558.           temp = savestring (polite_directory_format (t_string));
  3559.         goto add_string;
  3560.           }
  3561.       
  3562.         case 'u':
  3563.           {
  3564.         extern char *current_user_name;
  3565.         temp = savestring (current_user_name);
  3566.  
  3567.         goto add_string;
  3568.           }
  3569.  
  3570.         case 'h':
  3571.           {
  3572.         extern char *current_host_name;
  3573.         char *t_string;
  3574.  
  3575.         temp = savestring (current_host_name);
  3576.         if (t_string = (char *)index (temp, '.'))
  3577.           *t_string = '\0';
  3578.         
  3579.         goto add_string;
  3580.           }
  3581.  
  3582.         case '#':
  3583.           {
  3584.         extern int current_command_number;
  3585.         char number_buffer[20];
  3586.         sprintf (number_buffer, "%d", current_command_number);
  3587.         temp = savestring (number_buffer);
  3588.         goto add_string;
  3589.           }
  3590.  
  3591.         case '!':
  3592.           {
  3593.         extern int history_base, where_history ();
  3594.         char number_buffer[20];
  3595.  
  3596.         using_history ();
  3597.         if (get_string_value ("HISTSIZE"))
  3598.           sprintf (number_buffer, "%d",
  3599.                history_base + where_history ());
  3600.         else
  3601.           strcpy (number_buffer, "!");
  3602.         temp = savestring (number_buffer);
  3603.         goto add_string;
  3604.           }
  3605.  
  3606.         case '$':
  3607.           temp = savestring (geteuid () == 0 ? "#" : "$");
  3608.           goto add_string;
  3609.  
  3610.         case '\\':
  3611.           temp = savestring ("\\");
  3612.           goto add_string;
  3613.  
  3614.         default:
  3615.           temp = savestring ("\\ ");
  3616.           temp[1] = c;
  3617.  
  3618.         add_string:
  3619.           if (c)
  3620.         string++;
  3621.           result =
  3622.         (char *)sub_append_string (temp, result,
  3623.                        &result_index, &result_size);
  3624.           temp = (char *)NULL; /* Free ()'ed in sub_append_string (). */
  3625.           result[result_index] = '\0';
  3626.           break;
  3627.         }
  3628.     }
  3629.       else
  3630.     {
  3631.       while (3 + result_index > result_size)
  3632.         result = (char *)xrealloc (result, result_size += PROMPT_GROWTH);
  3633.  
  3634.       result[result_index++] = c;
  3635.       result[result_index] = '\0';
  3636.     }
  3637.     }
  3638.  
  3639.   /* I don't really think that this is a good idea.  Do you? */
  3640.   if (!find_variable ("NO_PROMPT_VARS"))
  3641.     {
  3642.       WORD_LIST *expand_string (), *list;
  3643.       char *string_list ();
  3644.  
  3645.       list = expand_string (result, 1);
  3646.       free (result);
  3647.       result = string_list (list);
  3648.       dispose_words (list);
  3649.     }
  3650.  
  3651.   return (result);
  3652. }
  3653.  
  3654. /* Report a syntax error, and restart the parser.  Call here for fatal
  3655.    errors. */
  3656. yyerror ()
  3657. {
  3658.   report_syntax_error ((char *)NULL);
  3659.   reset_parser ();
  3660. }
  3661.  
  3662. /* Report a syntax error with line numbers, etc.
  3663.    Call here for recoverable errors.  If you have a message to print,
  3664.    then place it in MESSAGE, otherwise pass NULL and this will figure
  3665.    out an appropriate message for you. */
  3666. report_syntax_error (message)
  3667.      char *message;
  3668. {
  3669.   if (message)
  3670.     {
  3671.       if (!interactive)
  3672.     {
  3673.       char *name = bash_input.name ? bash_input.name : "stdin";
  3674.       report_error ("%s:%d: `%s'", name, line_number, message);
  3675.     }
  3676.       else
  3677.     report_error ("%s", message);
  3678.  
  3679.       return;
  3680.     }
  3681.  
  3682.   if (shell_input_line && *shell_input_line)
  3683.     {
  3684.       char *error_token, *t = shell_input_line;
  3685.       register int i = shell_input_line_index;
  3686.       int token_end = 0;
  3687.  
  3688.       if (!t[i] && i)
  3689.     i--;
  3690.  
  3691.       while (i && (t[i] == ' ' || t[i] == '\t' || t[i] == '\n'))
  3692.     i--;
  3693.  
  3694.       if (i)
  3695.     token_end = i + 1;
  3696.  
  3697.       while (i && !member (t[i], " \n\t;|&"))
  3698.     i--;
  3699.  
  3700.       while (i != token_end && member (t[i], " \n\t"))
  3701.     i++;
  3702.  
  3703.       if (token_end)
  3704.     {
  3705.       error_token = (char *)alloca (1 + (token_end - i));
  3706.       strncpy (error_token, t + i, token_end - i);
  3707.       error_token[token_end - i] = '\0';
  3708.  
  3709.       report_error ("syntax error near `%s'", error_token);
  3710.     }
  3711.       else if ((i == 0) && (token_end == 0))    /* a 1-character token */
  3712.     {
  3713.       error_token = (char *) alloca (2);
  3714.       strncpy(error_token, t + i, 1);
  3715.       error_token[1] = '\0';
  3716.  
  3717.       report_error ("syntax error near `%s'", error_token);
  3718.     }
  3719.  
  3720.       if (!interactive)
  3721.     {
  3722.       char *temp = savestring (shell_input_line);
  3723.       char *name = bash_input.name ? bash_input.name : "stdin";
  3724.       int l = strlen (temp);
  3725.  
  3726.       while (l && temp[l - 1] == '\n')
  3727.         temp[--l] = '\0';
  3728.  
  3729.       report_error ("%s:%d: `%s'", name, line_number, temp);
  3730.       free (temp);
  3731.     }
  3732.     }
  3733.   else
  3734.     report_error ("Syntax error");
  3735. }
  3736.  
  3737. /* ??? Needed function. ??? We have to be able to discard the constructs
  3738.    created during parsing.  In the case of error, we want to return
  3739.    allocated objects to the memory pool.  In the case of no error, we want
  3740.    to throw away the information about where the allocated objects live.
  3741.    (dispose_command () will actually free the command. */
  3742. discard_parser_constructs (error_p)
  3743.      int error_p;
  3744. {
  3745. /*   if (error_p) {
  3746.      fprintf (stderr, "*");
  3747.   } */
  3748. }
  3749.    
  3750. /* Do that silly `type "bye" to exit' stuff.  You know, "ignoreeof". */
  3751.  
  3752. /* The number of times that we have encountered an EOF character without
  3753.    another character intervening.  When this gets above the limit, the
  3754.    shell terminates. */
  3755. int eof_encountered = 0;
  3756.  
  3757. /* The limit for eof_encountered. */
  3758. int eof_encountered_limit = 10;
  3759.  
  3760. /* If we have EOF as the only input unit, this user wants to leave
  3761.    the shell.  If the shell is not interactive, then just leave.
  3762.    Otherwise, if ignoreeof is set, and we haven't done this the
  3763.    required number of times in a row, print a message. */
  3764. handle_eof_input_unit ()
  3765. {
  3766.   extern int login_shell, EOF_Reached;
  3767.  
  3768.   if (interactive)
  3769.     {
  3770.       /* If the user wants to "ignore" eof, then let her do so, kind of. */
  3771.       if (find_variable ("ignoreeof") || find_variable ("IGNOREEOF"))
  3772.     {
  3773.       if (eof_encountered < eof_encountered_limit)
  3774.         {
  3775.           fprintf (stderr, "Use \"%s\" to leave the shell.\n",
  3776.                login_shell ? "logout" : "exit");
  3777.           eof_encountered++;
  3778.           /* Reset the prompt string to be $PS1. */
  3779.           prompt_string_pointer = (char **)NULL;
  3780.           prompt_again ();
  3781.           last_read_token = current_token = '\n';
  3782.           return;
  3783.         } 
  3784.     }
  3785.  
  3786.       /* In this case EOF should exit the shell.  Do it now. */
  3787.       reset_parser ();
  3788.       exit_builtin ((WORD_LIST *)NULL);
  3789.     }
  3790.   else
  3791.     {
  3792.       /* We don't write history files, etc., for non-interactive shells. */
  3793.       EOF_Reached = 1;
  3794.     }
  3795. }
  3796.